+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
+Wed Oct 25 14:17:43 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (gtk_widget_is_focus): Add a function
+ to determine if a window is the focus widget within
+ its toplevel.
+
+ * gtk/gtkcontainer.[ch]: Fix the return type of ::focus
+ to be boolean.
+
+ * gtk/gtkcontainer.c (gtk_container_real_focus): Move handling
+ of the case where the container CAN_FOCUS to here instead
+ of having it in each individual move-the-focus place.
+
+ * gtk/gtkcontainer.c: Rewrite handling of left-right and up-down
+ focusing to be geometric in a much more obvious sense. Arrowing
+ around is still non-intuitive because it isn't perfect and
+ because entries, etc, grab the arrow keys, but it at least
+ usually will do what you expect now.
+
+ * gtk/gtknotebook.[ch]: Many cleanups. Moved docs inline in this
+ file.
+
+ * gtk/gtknotebook.c: Change tabs to be a single item in
+ the focus chain. Make movement of focus on tabs with arrow
+ keys wrap around.
+
+ * gtk/gtknotebook.c (gtk_notebook_find_child): Add
+ CHECK_FIND_CHILD macro to give informative error messages
+ instead of silent returns.
+
+ * gtk/gtknotebook.c (gtk_notebook_init): Set the RECEIVES_DEFAULT
+ flag since we handle GdkReturn on the tabs.
+
+ * gtk/gtknotebook.c (gtk_notebook_expose_tabs): Invalidate
+ windows rather than sending expose events directly.
+
+ * gtk/gtknotebook.[ch] docs/Changes-2.0.txt: Move structure
+ definition for GtkNotebookPage into .c file, since it is private.
+
+ * gtk/testgtk.c (create_notebook): Add option for
+ testing borderless notebook.
+
+ * gtk/testgtk.c (page_switch): Removed egregious poking
+ around in GTK+ internals.
+
+ * docs/widget-system.txt: Remove references to GTK_REDRAW_PENDING.
+
+ * gtk/gtkclist.[ch]: Remove key press handler, handle focusing
+ properly through gtk_clist_focus. Make the title headers a
+ single item in the tab-focus chain, and make left-right wrap
+ around.
+
+ * gtk/gtkwindow.c (gtk_window_focus): Add a custom
+ focus method so that wrapping around works properly.
+
+ * gtk/gtktreeview.c: Remove calls to gtk_container_set_focus_child() -
+ that is handled for the widget now.
+
Mon Dec 11 11:41:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkinvisible.c (gtk_invisible_init): Flag invisible
2000-12-06 Elliot Lee <sopwith@redhat.com>
* configure.in: Detect freetype properly
+
* modules/basic/Makefile.am, gdk/linux-fb/Makefile.am: Make use of
above.
void gtk_progress_bar_set_orientation (GtkProgressBar *pbar,
GtkProgressBarOrientation orientation);
+* The GtkNotebookPage structure has been removed from the public header files;
+ this was never meant to be a public structure, and all functionality that
+ could be done by accessing the struct fields of this structure should be
+ accesible otherwise.
- GtkMenuPositionFunc has a new parameter push_in which controls how
menus placed outside the screen is handled. If this is set to true and
+Wed Oct 25 15:19:40 2000 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/tmpl/gtknotebook.sgml: Moved function docs into .c
+ file, fairly extensive rewriting.
+
Thu Nov 30 00:53:45 2000 Owen Taylor <otaylor@redhat.com>
* gtk/tmpl/gtkfilesel.sgml: Fix to say that file_selection_complete()
GtkNotebook
<!-- ##### SECTION Short_Description ##### -->
-Set of pages with bookmarks.
+A tabbed notebook container.
<!-- ##### SECTION Long_Description ##### -->
<para>
The #GtkNotebook widget is a #GtkContainer whose children are pages that
-can be accessed through bookmarks. The pages are displayed all at the same
-place. <!-- TODO: talk about the menu -->
+can be switched between using tab labels along one edge.
+</para>
+<para>
+There are many configuration options for #GtkNotebook. Among other
+things, you can choose on which edge the tabs appear
+(see gtk_notebook_set_tab_pos()), whether, if there are too many
+tabs to fit the noteobook should be made bigger or scrolling
+arrows added (see gtk_notebook_set_scrollable), and whether there
+will be a popup menu allowing the users to switch pages.
+(see gtk_notebook_enable_popup(), gtk_noteobook_disable_popup())
</para>
<!-- ##### SECTION See_Also ##### -->
</para>
-<!-- ##### MACRO GTK_NOTEBOOK_PAGE ##### -->
-<para>
-Extracts the contents of the current element of #GList @_glist_ as a
-#GtkNotebookPage.
-</para>
-
-@_glist_:
-
-
<!-- ##### STRUCT GtkNotebookPage ##### -->
<para>
-The #GtkNotebookPage structure is used to store the pages of a notebook. It
-is not an object.
+The #GtkNotebookPage is an opaque implementation detail of #GtkNotebook.
</para>
-@child: the contents of the page
-@tab_label: the label shown in the bookmark
-@menu_label: the label shown in the popup menu
-@default_menu:
-@default_tab:
-@expand:
-@fill:
-@pack:
-@requisition:
-@allocation:
-
<!-- ##### FUNCTION gtk_notebook_new ##### -->
<para>
-Creates a new #GtkNotebook widget
</para>
-@Returns: the newly created G=#GtkNotebook
+@Returns:
<!-- ##### FUNCTION gtk_notebook_append_page ##### -->
<para>
-Appends to @notebook a page whose content is @child, and whose bookmark is
-@tab_label.
</para>
-@notebook: the notebook widget
-@child: the content of the new page
-@tab_label: the bookmark for the page
+@notebook:
+@child:
+@tab_label:
<!-- ##### FUNCTION gtk_notebook_append_page_menu ##### -->
<para>
-Appends to @notebook a page whose content is @child, whose bookmark is
-@tab_label, and whose menu label is @menu_label.
</para>
-@notebook: the notebook widget
-@child: the content of the new page
-@tab_label: the bookmark of the page
-@menu_label: the menu label of the page
+@notebook:
+@child:
+@tab_label:
+@menu_label:
<!-- ##### FUNCTION gtk_notebook_prepend_page ##### -->
<para>
-Prepends to @notebook a page whose content is @child, whose bookmark is
-@tab_label, and whose menu label is @menu_label.
</para>
-@notebook: the notebook widget
-@child: the content of the new page
-@tab_label: the bookmark of the page
+@notebook:
+@child: the
+@tab_label:
<!-- ##### FUNCTION gtk_notebook_prepend_page_menu ##### -->
<para>
-Appends to @notebook a page whose content is @child, whose bookmark is
-@tab_label, and whose menu label is @menu_label.
</para>
-@notebook: the notebook widget
-@child: the content of the new page
-@tab_label: the bookmark of the page
-@menu_label: the menu label of the page
+@notebook:
+@child:
+@tab_label:
+@menu_label:
<!-- ##### FUNCTION gtk_notebook_insert_page ##### -->
<para>
-Inserts in @notebook a new page whose content is @child, and whose
-bookmark is @tab_label. The page is inserted just
-before the page number @position, starting with 0. If @position is out of
-bounds, it is assumed to be the current number of pages.
</para>
-@notebook: the notebook widget
-@child: the content of the new page
-@tab_label: the bookmark of the page
-@position: the position to insert the page
+@notebook:
+@child:
+@tab_label:
+@position:
<!-- ##### FUNCTION gtk_notebook_insert_page_menu ##### -->
<para>
-Inserts in @notebook a new page whose content is @child, whose bookmark is
-@tab_label, and whose menu label is @menu_label. The page is inserted just
-before the page number @position, starting with 0. If @position is out of
-bounds, it is assumed to be the current number of pages.
</para>
-@notebook: the notebook widget
-@child: the content of the new page
-@tab_label: the bookmark of the page
-@menu_label: the menu label of the page
-@position: the position to insert the page
+@notebook:
+@child:
+@tab_label:
+@menu_label:
+@position:
<!-- ##### FUNCTION gtk_notebook_remove_page ##### -->
<para>
-Removes the page @page_num form @notebook. Pages are numbered starting at
-zero. Negative values stand for the last page; too large values are
-ignored.
</para>
-@notebook: the notebook widget
-@page_num: the page number
+@notebook:
+@page_num:
<!-- ##### MACRO gtk_notebook_current_page ##### -->
<!-- ##### FUNCTION gtk_notebook_page_num ##### -->
<para>
-Returns the page number of @child in @notebook.
</para>
-@notebook: the notebook widget
-@child: the child
-@Returns: the page number, or -1 if @child is not in @notebook
+@notebook:
+@child:
+@Returns:
<!-- ##### FUNCTION gtk_notebook_set_page ##### -->
<para>
-Switches to the page number @page_num. Negative values stand for the last
-page; too large values are ignored.
</para>
-@notebook: the notebook widget
-@page_num: the page number
+@notebook:
+@page_num:
<!-- ##### FUNCTION gtk_notebook_next_page ##### -->
<para>
-Switches to the next page. Nothing happens if the current page is the last
-page.
</para>
-@notebook: the notebook widget.
+@notebook:
<!-- ##### FUNCTION gtk_notebook_prev_page ##### -->
<para>
-Switches to the previous page. Nothing happens if the current page is the
-first page.
</para>
-@notebook: the notebook widget
+@notebook:
<!-- ##### FUNCTION gtk_notebook_reorder_child ##### -->
<para>
-Moves the page @child, so that it appears in position @position. Out of
-bounds @position will be clamped.
</para>
-@notebook: the notebook widget
-@child: the child to deplace
-@position: the new position
-
+@notebook
+@child:
+@position:
<!-- ##### FUNCTION gtk_notebook_set_tab_pos ##### -->
<para>
-Sets the position of the bookmarks.
</para>
@notebook: the notebook widget
<!-- ##### FUNCTION gtk_notebook_set_show_tabs ##### -->
<para>
-Sets whether to show the bookmarks or not.
</para>
-@notebook: the notebook widget
-@show_tabs: a boolean value
+@notebook:
+@show_tabs:
<!-- ##### FUNCTION gtk_notebook_set_show_border ##### -->
<para>
-Sets whether to show the border of the notebook or not. Bookmarks are in the
-border.
</para>
-@notebook: the notebook widget
-@show_border: a boolean value
+@notebook:
+@show_border:
<!-- ##### FUNCTION gtk_notebook_set_scrollable ##### -->
<para>
-Sets whether the bookmarks area may be scrollable or not if there are too
-many bookmarks to fit in the allocated area.
</para>
-@notebook: the notebook widget
-@scrollable: a boolean value
+@notebook:
+@scrollable:
<!-- ##### FUNCTION gtk_notebook_set_tab_border ##### -->
<para>
-Sets whether there should be a border around the bookmarks or not.
</para>
-@notebook: the notebook widget
-@border_width: a boolean value
+@notebook:
+@border_width:
<!-- ##### FUNCTION gtk_notebook_popup_enable ##### -->
<para>
-Enables the popup menu: if the user clicks with the right mouse button on
-the bookmarks, a menu with all the pages will be popped up.
</para>
-@notebook: the notebook widget
+@notebook:
<!-- ##### FUNCTION gtk_notebook_popup_disable ##### -->
<para>
-Disables the popup menu
</para>
-@notebook: the notebook widget
-
+@notebook:
<!-- ##### FUNCTION gtk_notebook_get_current_page ##### -->
<para>
-Returns the page number of the current page.
</para>
@notebook: the notebook widget
<!-- ##### FUNCTION gtk_notebook_get_menu_label ##### -->
<para>
-Returns the menu label of the page @child. NULL is returned if @child is not
-in @notebook or NULL if it has the default menu label.
</para>
-@notebook: the notebook widget
-@child: the page
-@Returns: the menu label
+@notebook:
+@child:
+@Returns:
<!-- ##### FUNCTION gtk_notebook_get_nth_page ##### -->
<para>
-Returns the content of the page number @page_num, or NULL if @page_num is
-out of bounds.
</para>
-@notebook: the notebook widget
-@page_num: the page number
-@Returns: the content of the page
+@notebook:
+@page_num:
+@Returns:
<!-- ##### FUNCTION gtk_notebook_get_tab_label ##### -->
<para>
-Returns the menu tab of the page @child. NULL is returned if @child is not
-in @notebook or NULL if it has the default tab label.
</para>
-@notebook: the notebook widget
-@child: the page
-@Returns: the tab label
+@notebook:
+@child:
+@Returns:
<!-- ##### FUNCTION gtk_notebook_query_tab_label_packing ##### -->
<para>
-Looks for the packing attributes of the bookmarks of @child.
</para>
-@notebook: the notebook widget
-@child: the page
-@expand: a pointer to return the expand value (or NULL)
-@fill: a pointer to return the fill value (or NULL)
-@pack_type: a pointer to return the pack_type (or NULL)
+@notebook:
+@child:
+@expand:
+@fill:
+@pack_type:
<!-- ##### FUNCTION gtk_notebook_set_homogeneous_tabs ##### -->
<para>
-Sets whether the tabs must have all the same size or not.
</para>
-@notebook: the notebook widget
-@homogeneous: a boolean value
+@notebook:
+@homogeneous:
<!-- ##### FUNCTION gtk_notebook_set_menu_label ##### -->
<para>
-Changes the menu label of @child. Nothing happens if @child is not in
-@notebook.
</para>
-@notebook: the notebook widget
-@child: the page
-@menu_label: the menu label, or NULL for default
+@notebook:
+@child:
+@menu_label:
<!-- ##### FUNCTION gtk_notebook_set_menu_label_text ##### -->
<para>
-Creates a new label and sets it as the menu label of @child.
</para>
-@notebook: the notebook widget
-@child: the page
-@menu_text: the label text
<!-- ##### FUNCTION gtk_notebook_set_tab_hborder ##### -->
<para>
-Sets whether the tabs should have a horizontal border.
</para>
-@notebook: the notebook widget
-@tab_hborder: a boolean value
+@notebook:
+@tab_hborder:
<!-- ##### FUNCTION gtk_notebook_set_tab_label ##### -->
<para>
-Changes the bookmark label of @child. Nothing happens if @child is not in
-@notebook.
</para>
-@notebook: the notebook widget
-@child: the page
-@tab_label: the bookmark label, or NULL for default
+@notebook:
+@child:
+@tab_label:
<!-- ##### FUNCTION gtk_notebook_set_tab_label_packing ##### -->
<para>
-Sets the packing parameters for the bookmark of @child. See
-#GtkBoxPackStart for the exact meanings.
</para>
-@notebook: the notebook widget
-@child: the child widget
-@expand: whether to expand the bookmark or not
-@fill: whether the bookmark should fill the allocated area or not
-@pack_type: the position of the bookmark
+@notebook:
+@child:
+@expand:
+@fill:
+@pack_type:
<!-- ##### FUNCTION gtk_notebook_set_tab_label_text ##### -->
<para>
-Creates a new label and sets it as the bookmark label of @child.
</para>
-@notebook: the notebook widget
-@child: the page
-@tab_text: the label text
+@notebook:
+@child:
+@tab_text:
<!-- ##### FUNCTION gtk_notebook_set_tab_vborder ##### -->
<para>
-Sets whether the tabs should have a vertical border.
</para>
-@notebook: the notebook widget
-@tab_vborder: a boolean value
+@notebook:
+@tab_vborder:
<!-- ##### SIGNAL GtkNotebook::switch-page ##### -->
<!-- ##### ARG GtkNotebook:tab_pos ##### -->
<para>
-The position of the bookmarks
+The edge at which the tabs for switching pages are drawn.
</para>
<!-- ##### ARG GtkNotebook:tab_border ##### -->
<para>
-Whether the bookmarks have a border or not
+Whether the tab labels have a border on all sides.
</para>
<!-- ##### ARG GtkNotebook:tab_hborder ##### -->
<para>
-Whether the bookmarks have a horizontal border or not
+Whether the tab labels have a horizontal border.
</para>
<!-- ##### ARG GtkNotebook:tab_vborder ##### -->
<para>
-Whether the bookmarks have a vertical border or not
+Whether the tab labels have a vertical border.
</para>
<!-- ##### ARG GtkNotebook:show_tabs ##### -->
<para>
-Whether to show the bookmarks or not
+Whether to show tabs for the notebook pages.
</para>
<!-- ##### ARG GtkNotebook:show_border ##### -->
<para>
-Whether to show the border or not
+Whether to draw a bevel around the noteobook.
</para>
<!-- ##### ARG GtkNotebook:scrollable ##### -->
<para>
-Whether the bookmarks should be scrollable or not
+Whether the tab label area will have arrows for scrolling if there
+are too many tabs to fit in the area.
</para>
<!-- ##### ARG GtkNotebook:enable_popup ##### -->
<para>
-Whether the popup menu is enabled or not
+Whether the popup menu for switching pages is enabled.
</para>
<!-- ##### ARG GtkNotebook:homogeneous ##### -->
<para>
-
+whether the tabs must have all the same size.
</para>
wich share a global user style from the ones which got a certain
style assign from outside the toolkit.
-GTK_REDRAW_PENDING:
- Relies on GTK_WIDGET_MAPPED (widget).
- [FIXME: this is not really enforced throughout the code, but should
- be. it only requires a few checks for GTK_WIDGET_MAPPED and
- minor changes to gtk_widget_unmap, we can then remove the check
- in gtk_widget_real_destroy]
- Means: there is an idle handler waiting for the widget, that
- will cause a full redraw (gtk_widget_draw (widget, NULL)).
-
GTK_RESIZE_PENDING:
First, this is only valid for GtkContainers.
[some of the code should move to gtkcontainer.c therefore]
Note:, the definition
[ GTK_WIDGET_DRAWABLE = GTK_WIDGET_VISIBLE && GTK_WIDGET_MAPPED
- is made in gtkwidget.c, but by 3) and 5),
+ is made in gtkwidget.h, but by 3) and 5),
GTK_WIDGET_MAPPED => GTK_WIDGET_VISIBLE
]
static void gtk_clist_unmap (GtkWidget *widget);
static gint gtk_clist_expose (GtkWidget *widget,
GdkEventExpose *event);
-static gint gtk_clist_key_press (GtkWidget *widget,
- GdkEventKey *event);
static gint gtk_clist_button_press (GtkWidget *widget,
GdkEventButton *event);
static gint gtk_clist_button_release (GtkWidget *widget,
GdkEventFocus *event);
static gint gtk_clist_focus (GtkContainer *container,
GtkDirectionType direction);
+static void gtk_clist_set_focus_child (GtkContainer *container,
+ GtkWidget *child);
static void gtk_clist_style_set (GtkWidget *widget,
GtkStyle *previous_style);
static void gtk_clist_drag_begin (GtkWidget *widget,
guint time);
/* GtkContainer Methods */
-static void gtk_clist_set_focus_child (GtkContainer *container,
- GtkWidget *child);
static void gtk_clist_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
GList *list,
gint num);
/* Misc */
-static gboolean title_focus (GtkCList *clist,
- gint dir);
+static gboolean title_focus_in (GtkCList *clist,
+ gint dir);
+static gboolean title_focus_move (GtkCList *clist,
+ gint dir);
+
static void real_row_move (GtkCList *clist,
gint source_row,
gint dest_row);
widget_class->expose_event = gtk_clist_expose;
widget_class->size_request = gtk_clist_size_request;
widget_class->size_allocate = gtk_clist_size_allocate;
- widget_class->key_press_event = gtk_clist_key_press;
widget_class->focus_in_event = gtk_clist_focus_in;
widget_class->focus_out_event = gtk_clist_focus_out;
widget_class->draw_focus = gtk_clist_draw_focus;
GTK_WIDGET_UNSET_FLAGS (clist, GTK_NO_WINDOW);
GTK_WIDGET_SET_FLAGS (clist, GTK_CAN_FOCUS);
- GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
GTK_CLIST_SET_FLAG (clist, CLIST_DRAW_DRAG_LINE);
GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
clist->undo_unselection = NULL;
clist->focus_row = -1;
+ clist->focus_header_column = -1;
clist->undo_anchor = -1;
clist->anchor = -1;
* gtk_clist_unmap
* gtk_clist_expose
* gtk_clist_style_set
- * gtk_clist_key_press
* gtk_clist_button_press
* gtk_clist_button_release
* gtk_clist_motion
attributes.event_mask |= (GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
- GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
attributes.event_mask = (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
- GDK_POINTER_MOTION_HINT_MASK |
- GDK_KEY_PRESS_MASK);
+ GDK_POINTER_MOTION_HINT_MASK);
attributes_mask = GDK_WA_CURSOR;
attributes.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
clist->cursor_drag = attributes.cursor;
}
}
-static gint
-gtk_clist_key_press (GtkWidget *widget,
- GdkEventKey *event)
-{
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- if (GTK_WIDGET_CLASS (parent_class)->key_press_event &&
- GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
- return TRUE;
-
- switch (event->keyval)
- {
- case GDK_Tab:
- case GDK_ISO_Left_Tab:
- if (event->state & GDK_SHIFT_MASK)
- return gtk_container_focus (GTK_CONTAINER (widget),
- GTK_DIR_TAB_BACKWARD);
- else
- return gtk_container_focus (GTK_CONTAINER (widget),
- GTK_DIR_TAB_FORWARD);
- default:
- break;
- }
- return FALSE;
-}
-
static gint
gtk_clist_button_press (GtkWidget *widget,
GdkEventButton *event)
gpointer data)
{
GtkCList *clist;
+ GtkContainer *container;
GdkRectangle area;
gint i;
gint y = 0;
g_return_if_fail (GTK_IS_CLIST (data));
clist = GTK_CLIST (data);
+ container = GTK_CONTAINER (data);
if (!GTK_WIDGET_DRAWABLE (clist) || adjustment != clist->hadjustment)
return;
}
if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
- !GTK_CLIST_CHILD_HAS_FOCUS(clist) && GTK_CLIST_ADD_MODE(clist))
+ !container->focus_child && GTK_CLIST_ADD_MODE(clist))
{
y = ROW_TOP_YPIXEL (clist, clist->focus_row);
}
if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
- !GTK_CLIST_CHILD_HAS_FOCUS(clist) && GTK_CLIST_ADD_MODE(clist))
+ !container->focus_child && GTK_CLIST_ADD_MODE(clist))
{
y = ROW_TOP_YPIXEL (clist, clist->focus_row);
check_exposures (clist);
if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
- !GTK_CLIST_CHILD_HAS_FOCUS(clist))
+ !container->focus_child)
{
if (GTK_CLIST_ADD_MODE(clist))
{
}
/* FOCUS FUNCTIONS
+ * gtk_clist_focus_content_area
* gtk_clist_focus
* gtk_clist_draw_focus
* gtk_clist_focus_in
* gtk_clist_focus_out
- * gtk_clist_set_focus_child
* title_focus
*/
-static gint
+static void
+gtk_clist_focus_content_area (GtkCList *clist)
+{
+ if (clist->focus_row < 0)
+ {
+ clist->focus_row = 0;
+
+ if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
+ clist->selection_mode == GTK_SELECTION_EXTENDED) &&
+ !clist->selection)
+ gtk_signal_emit (GTK_OBJECT (clist),
+ clist_signals[SELECT_ROW],
+ clist->focus_row, -1, NULL);
+ }
+ gtk_widget_grab_focus (GTK_WIDGET (clist));
+}
+
+static gboolean
gtk_clist_focus (GtkContainer *container,
GtkDirectionType direction)
{
- GtkCList *clist;
- GtkWidget *focus_child;
- gint old_row;
-
- g_return_val_if_fail (container != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_CLIST (container), FALSE);
+ GtkCList *clist = GTK_CLIST (container);
+ GtkWidget *focus_child = container->focus_child;
+ gboolean is_current_focus;
if (!GTK_WIDGET_IS_SENSITIVE (container))
return FALSE;
-
- clist = GTK_CLIST (container);
- focus_child = container->focus_child;
- old_row = clist->focus_row;
+ is_current_focus = gtk_widget_is_focus (GTK_WIDGET (clist));
+
+ if (focus_child &&
+ GTK_IS_CONTAINER (focus_child) &&
+ GTK_WIDGET_DRAWABLE (focus_child) &&
+ GTK_WIDGET_IS_SENSITIVE (focus_child) &&
+ gtk_container_focus (GTK_CONTAINER (focus_child), direction))
+ return TRUE;
+
switch (direction)
{
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
- if (GTK_CLIST_CHILD_HAS_FOCUS(clist))
+ if (focus_child)
{
- if (title_focus (clist, direction))
+ if (title_focus_move (clist, direction))
return TRUE;
- gtk_container_set_focus_child (container, NULL);
- return FALSE;
- }
- gtk_widget_grab_focus (GTK_WIDGET (container));
- return TRUE;
+ }
+ else if (!is_current_focus)
+ {
+ gtk_clist_focus_content_area (clist);
+ return TRUE;
+ }
+ break;
case GTK_DIR_DOWN:
case GTK_DIR_TAB_FORWARD:
- if (GTK_CLIST_CHILD_HAS_FOCUS(clist))
+ if (!focus_child && !is_current_focus)
{
- gboolean tf = FALSE;
-
- if (((focus_child && direction == GTK_DIR_DOWN) ||
- !(tf = title_focus (clist, GTK_DIR_TAB_FORWARD)))
- && clist->rows)
- {
- if (clist->focus_row < 0)
- {
- clist->focus_row = 0;
-
- if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
- clist->selection_mode == GTK_SELECTION_EXTENDED) &&
- !clist->selection)
- gtk_signal_emit (GTK_OBJECT (clist),
- clist_signals[SELECT_ROW],
- clist->focus_row, -1, NULL);
- }
- gtk_widget_grab_focus (GTK_WIDGET (container));
- return TRUE;
- }
-
- if (tf)
+ if (title_focus_in (clist, direction))
return TRUE;
}
- GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
+ if (!is_current_focus && clist->rows)
+ {
+ gtk_clist_focus_content_area (clist);
+ return TRUE;
+ }
break;
case GTK_DIR_UP:
case GTK_DIR_TAB_BACKWARD:
- if (!focus_child &&
- GTK_CLIST_CHILD_HAS_FOCUS(clist) && clist->rows)
+ if (!focus_child && is_current_focus)
{
- if (clist->focus_row < 0)
- {
- clist->focus_row = 0;
- if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
- clist->selection_mode == GTK_SELECTION_EXTENDED) &&
- !clist->selection)
- gtk_signal_emit (GTK_OBJECT (clist),
- clist_signals[SELECT_ROW],
- clist->focus_row, -1, NULL);
- }
- gtk_widget_grab_focus (GTK_WIDGET (container));
+ if (title_focus_in (clist, direction))
+ return TRUE;
+ }
+
+ if (!is_current_focus && !focus_child && clist->rows)
+ {
+ gtk_clist_focus_content_area (clist);
return TRUE;
}
-
- GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
-
- if (title_focus (clist, direction))
- return TRUE;
-
break;
default:
break;
}
- gtk_container_set_focus_child (container, NULL);
return FALSE;
}
+static void
+gtk_clist_set_focus_child (GtkContainer *container,
+ GtkWidget *child)
+{
+ GtkCList *clist = GTK_CLIST (container);
+ gint i;
+
+ for (i = 0; i < clist->columns; i++)
+ if (clist->column[i].button == child)
+ clist->focus_header_column = i;
+
+ parent_class->set_focus_child (container, child);
+}
+
static void
gtk_clist_draw_focus (GtkWidget *widget)
{
g_return_val_if_fail (event != NULL, FALSE);
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
- GTK_CLIST_UNSET_FLAG (widget, CLIST_CHILD_HAS_FOCUS);
clist = GTK_CLIST (widget);
g_return_val_if_fail (event != NULL, FALSE);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
- GTK_CLIST_SET_FLAG (widget, CLIST_CHILD_HAS_FOCUS);
gtk_widget_draw_focus (widget);
return FALSE;
}
-static void
-gtk_clist_set_focus_child (GtkContainer *container,
- GtkWidget *child)
+static gboolean
+focus_column (GtkCList *clist, gint column, gint dir)
{
- g_return_if_fail (container != NULL);
- g_return_if_fail (GTK_IS_CLIST (container));
+ GtkWidget *child = clist->column[column].button;
+
+ if (GTK_IS_CONTAINER (child) &&
+ gtk_container_focus (GTK_CONTAINER (child), dir))
+ {
+ return TRUE;
+ }
+ else if (GTK_WIDGET_CAN_FOCUS (child))
+ {
+ gtk_widget_grab_focus (child);
+ return TRUE;
+ }
- if (child)
+ return FALSE;
+}
+
+/* Focus moved onto the headers. Focus first focusable and visible child.
+ * (FIXME: focus the last focused child if visible)
+ */
+static gboolean
+title_focus_in (GtkCList *clist, gint dir)
+{
+ gint i;
+ gint left, right;
+
+ /* Check last focused column */
+ if (clist->focus_header_column != -1)
+ {
+ i = clist->focus_header_column;
+
+ left = COLUMN_LEFT_XPIXEL (clist, i);
+ right = left + clist->column[i].area.width;
+
+ if (left >= 0 && right <= clist->clist_window_width)
+ {
+ if (focus_column (clist, i, dir))
+ return TRUE;
+ }
+ }
+
+ /* Check fully visible columns */
+ for (i = 0 ; i < clist->columns ; i++)
{
- g_return_if_fail (GTK_IS_WIDGET (child));
- GTK_CLIST_SET_FLAG (container, CLIST_CHILD_HAS_FOCUS);
+ left = COLUMN_LEFT_XPIXEL (clist, i);
+ right = left + clist->column[i].area.width;
+
+ if (left >= 0 && right <= clist->clist_window_width)
+ {
+ if (focus_column (clist, i, dir))
+ return TRUE;
+ }
}
- parent_class->set_focus_child (container, child);
+ /* Check partially visible columns */
+ for (i = 0 ; i < clist->columns ; i++)
+ {
+ left = COLUMN_LEFT_XPIXEL (clist, i);
+ right = left + clist->column[i].area.width;
+
+ if ((left < 0 && right > 0) ||
+ (left < clist->clist_window_width && right > clist->clist_window_width))
+ {
+ if (focus_column (clist, i, dir))
+ return TRUE;
+ }
+ }
+
+ return FALSE;
}
+/* Move the focus right or left within the title buttons, scrolling
+ * as necessary to keep the focused child visible.
+ */
static gboolean
-title_focus (GtkCList *clist,
- gint dir)
+title_focus_move (GtkCList *clist,
+ gint dir)
{
GtkWidget *focus_child;
gboolean return_val = FALSE;
- gint last_column;
- gint d = 1;
- gint i = 0;
+ gint d = 0;
+ gint i = -1;
gint j;
if (!GTK_CLIST_SHOW_TITLES(clist))
return FALSE;
focus_child = GTK_CONTAINER (clist)->focus_child;
+ g_assert (focus_child);
- for (last_column = clist->columns - 1;
- last_column >= 0 && !clist->column[last_column].visible; last_column--)
- ;
-
+ /* Movement direction within headers
+ */
switch (dir)
{
- case GTK_DIR_TAB_BACKWARD:
- case GTK_DIR_UP:
- if (!focus_child || !GTK_CLIST_CHILD_HAS_FOCUS(clist))
- {
- if (dir == GTK_DIR_UP)
- i = COLUMN_FROM_XPIXEL (clist, 0);
- else
- i = last_column;
- focus_child = clist->column[i].button;
- dir = GTK_DIR_TAB_FORWARD;
- }
- else
- d = -1;
+ case GTK_DIR_RIGHT:
+ d = 1;
break;
case GTK_DIR_LEFT:
d = -1;
- if (!focus_child)
- {
- i = last_column;
- focus_child = clist->column[i].button;
- }
break;
- case GTK_DIR_RIGHT:
- if (!focus_child)
+ }
+
+ for (i = 0; i < clist->columns; i++)
+ if (clist->column[i].button == focus_child)
+ break;
+
+ g_assert (i != -1); /* Have a starting column */
+
+ j = i + d;
+ while (!return_val && j >= 0 && j < clist->columns)
+ {
+ if (clist->column[j].button &&
+ GTK_WIDGET_VISIBLE (clist->column[j].button))
{
- i = 0;
- focus_child = clist->column[i].button;
+ if (focus_column (clist, j, dir))
+ {
+ return_val = TRUE;
+ break;
+ }
}
- break;
+ j += d;
}
- if (focus_child)
- while (i < clist->columns)
- {
- if (clist->column[i].button == focus_child)
- {
- if (clist->column[i].button &&
- GTK_WIDGET_VISIBLE (clist->column[i].button) &&
- GTK_IS_CONTAINER (clist->column[i].button) &&
- !GTK_WIDGET_HAS_FOCUS(clist->column[i].button))
- if (gtk_container_focus
- (GTK_CONTAINER (clist->column[i].button), dir))
+ /* If we didn't find it, wrap around and keep looking
+ */
+ if (!return_val)
+ {
+ j = d > 0 ? 0 : clist->columns - 1;
+
+ while (!return_val && j != i)
+ {
+ if (clist->column[j].button &&
+ GTK_WIDGET_VISIBLE (clist->column[j].button))
+ {
+ if (focus_column (clist, j, dir))
{
return_val = TRUE;
- i -= d;
+ break;
}
- if (!return_val && dir == GTK_DIR_UP)
- return FALSE;
- i += d;
- break;
- }
- i++;
- }
-
- j = i;
+ }
+ j += d;
+ }
+ }
- if (!return_val)
- while (j >= 0 && j < clist->columns)
- {
- if (clist->column[j].button &&
- GTK_WIDGET_VISIBLE (clist->column[j].button))
- {
- if (GTK_IS_CONTAINER (clist->column[j].button) &&
- gtk_container_focus
- (GTK_CONTAINER (clist->column[j].button), dir))
- {
- return_val = TRUE;
- break;
- }
- else if (GTK_WIDGET_CAN_FOCUS (clist->column[j].button))
- {
- gtk_widget_grab_focus (clist->column[j].button);
- return_val = TRUE;
- break;
- }
- }
- j += d;
- }
-
+ /* Scroll horizontally so focused column is visible
+ */
if (return_val)
{
if (COLUMN_LEFT_XPIXEL (clist, j) < CELL_SPACING + COLUMN_INSET)
else if (COLUMN_LEFT_XPIXEL(clist, j) + clist->column[j].area.width >
clist->clist_window_width)
{
+ gint last_column;
+
+ for (last_column = clist->columns - 1;
+ last_column >= 0 && !clist->column[last_column].visible; last_column--);
+
if (j == last_column)
gtk_clist_moveto (clist, -1, j, 0, 0);
else
gtk_clist_moveto (clist, -1, j, 0, 1);
}
}
- return return_val;
+ return TRUE; /* Even if we didn't find a new one, we can keep the
+ * focus in the same place.
+ */
}
/* PRIVATE SCROLLING FUNCTIONS
GTK_CLIST_IN_DRAG = 1 << 0,
GTK_CLIST_ROW_HEIGHT_SET = 1 << 1,
GTK_CLIST_SHOW_TITLES = 1 << 2,
- GTK_CLIST_CHILD_HAS_FOCUS = 1 << 3,
+ /* Unused */
GTK_CLIST_ADD_MODE = 1 << 4,
GTK_CLIST_AUTO_SORT = 1 << 5,
GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 6,
#define GTK_CLIST_IN_DRAG(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_IN_DRAG)
#define GTK_CLIST_ROW_HEIGHT_SET(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_ROW_HEIGHT_SET)
#define GTK_CLIST_SHOW_TITLES(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_SHOW_TITLES)
-#define GTK_CLIST_CHILD_HAS_FOCUS(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_CHILD_HAS_FOCUS)
#define GTK_CLIST_ADD_MODE(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_ADD_MODE)
#define GTK_CLIST_AUTO_SORT(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_AUTO_SORT)
#define GTK_CLIST_AUTO_RESIZE_BLOCKED(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_AUTO_RESIZE_BLOCKED)
/* focus handling */
gint focus_row;
+
+ gint focus_header_column;
/* dragging the selection */
gint anchor;
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#include <stdarg.h>
#include <string.h>
+#include <stdlib.h>
+
#include "gtkcontainer.h"
#include "gtkprivate.h"
#include "gtksignal.h"
#include "gtkmain.h"
-#include <stdarg.h>
-
+#include "gtkwindow.h"
enum {
ADD,
guint seq_id;
};
-static void gtk_container_base_class_init (GtkContainerClass *klass);
-static void gtk_container_class_init (GtkContainerClass *klass);
-static void gtk_container_init (GtkContainer *container);
-static void gtk_container_destroy (GtkObject *object);
-static void gtk_container_get_arg (GtkObject *object,
- GtkArg *arg,
- guint arg_id);
-static void gtk_container_set_arg (GtkObject *object,
- GtkArg *arg,
- guint arg_id);
-static void gtk_container_add_unimplemented (GtkContainer *container,
- GtkWidget *widget);
-static void gtk_container_remove_unimplemented (GtkContainer *container,
- GtkWidget *widget);
-static void gtk_container_real_check_resize (GtkContainer *container);
-static gint gtk_container_real_focus (GtkContainer *container,
- GtkDirectionType direction);
-static void gtk_container_real_set_focus_child (GtkContainer *container,
- GtkWidget *widget);
-static gint gtk_container_focus_tab (GtkContainer *container,
- GList *children,
- GtkDirectionType direction);
-static gint gtk_container_focus_up_down (GtkContainer *container,
- GList *children,
- GtkDirectionType direction);
-static gint gtk_container_focus_left_right (GtkContainer *container,
- GList *children,
- GtkDirectionType direction);
-static gint gtk_container_focus_move (GtkContainer *container,
- GList *children,
- GtkDirectionType direction);
-static void gtk_container_children_callback (GtkWidget *widget,
- gpointer client_data);
-static void gtk_container_show_all (GtkWidget *widget);
-static void gtk_container_hide_all (GtkWidget *widget);
+static void gtk_container_base_class_init (GtkContainerClass *klass);
+static void gtk_container_class_init (GtkContainerClass *klass);
+static void gtk_container_init (GtkContainer *container);
+static void gtk_container_destroy (GtkObject *object);
+static void gtk_container_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_container_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_container_add_unimplemented (GtkContainer *container,
+ GtkWidget *widget);
+static void gtk_container_remove_unimplemented (GtkContainer *container,
+ GtkWidget *widget);
+static void gtk_container_real_check_resize (GtkContainer *container);
+static gboolean gtk_container_real_focus (GtkContainer *container,
+ GtkDirectionType direction);
+static void gtk_container_real_set_focus_child (GtkContainer *container,
+ GtkWidget *widget);
+static gboolean gtk_container_focus_tab (GtkContainer *container,
+ GList *children,
+ GtkDirectionType direction);
+static gboolean gtk_container_focus_up_down (GtkContainer *container,
+ GList **children,
+ GtkDirectionType direction);
+static gboolean gtk_container_focus_left_right (GtkContainer *container,
+ GList **children,
+ GtkDirectionType direction);
+static gboolean gtk_container_focus_move (GtkContainer *container,
+ GList *children,
+ GtkDirectionType direction);
+static void gtk_container_children_callback (GtkWidget *widget,
+ gpointer client_data);
+static void gtk_container_show_all (GtkWidget *widget);
+static void gtk_container_hide_all (GtkWidget *widget);
+
static gchar* gtk_container_child_default_composite_name (GtkContainer *container,
GtkWidget *child);
notify (callback_data);
}
-gint
+gboolean
gtk_container_focus (GtkContainer *container,
GtkDirectionType direction)
{
}
}
-static gint
+static gboolean
gtk_container_real_focus (GtkContainer *container,
GtkDirectionType direction)
{
if (GTK_WIDGET_CAN_FOCUS (container))
{
- gtk_widget_grab_focus (GTK_WIDGET (container));
- return_val = TRUE;
+ if (!GTK_WIDGET_HAS_FOCUS (container))
+ {
+ gtk_widget_grab_focus (GTK_WIDGET (container));
+ return_val = TRUE;
+ }
}
else
{
break;
case GTK_DIR_UP:
case GTK_DIR_DOWN:
- return_val = gtk_container_focus_up_down (container, children, direction);
+ return_val = gtk_container_focus_up_down (container, &children, direction);
break;
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
- return_val = gtk_container_focus_left_right (container, children, direction);
+ return_val = gtk_container_focus_left_right (container, &children, direction);
break;
}
return return_val;
}
-static gint
+static gboolean
gtk_container_focus_tab (GtkContainer *container,
GList *children,
GtkDirectionType direction)
return gtk_container_focus_move (container, children, direction);
}
-static gint
-gtk_container_focus_up_down (GtkContainer *container,
- GList *children,
- GtkDirectionType direction)
+static gboolean
+old_focus_coords (GtkContainer *container, GdkRectangle *old_focus_rect)
{
- GtkWidget *child;
- GtkWidget *child2;
- GList *tmp_list;
- gint dist1, dist2;
- gint focus_x;
- gint focus_width;
- guint length;
- guint i, j;
-
- /* return failure if there isn't a focus child */
- if (container->focus_child)
+ GtkWidget *widget = GTK_WIDGET (container);
+ GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+
+ if (toplevel &&
+ GTK_IS_WINDOW (toplevel) && GTK_WINDOW (toplevel)->focus_widget &&
+ GTK_WIDGET_REALIZED (container) &&
+ GTK_WIDGET_REALIZED (GTK_WINDOW (toplevel)->focus_widget))
{
- focus_width = container->focus_child->allocation.width / 2;
- focus_x = container->focus_child->allocation.x + focus_width;
+ GtkWidget *old_focus = GTK_WINDOW (toplevel)->focus_widget;
+ GdkWindow *old_parent_window = old_focus->parent ? old_focus->parent->window : old_focus->window;
+ GdkWindow *new_parent_window = widget->window;
+ GdkWindow *toplevel_window = toplevel->window;
+
+ *old_focus_rect = old_focus->allocation;
+
+ /* Translate coordinates to the toplevel */
+
+ while (old_parent_window != toplevel_window)
+ {
+ gint dx, dy;
+
+ gdk_window_get_position (old_parent_window, &dx, &dy);
+
+ old_focus_rect->x += dx;
+ old_focus_rect->y += dy;
+
+ old_parent_window = gdk_window_get_parent (old_parent_window);
+ }
+
+ /* Translate coordinates back to the new container */
+
+ while (new_parent_window != toplevel_window)
+ {
+ gint dx, dy;
+
+ gdk_window_get_position (new_parent_window, &dx, &dy);
+
+ old_focus_rect->x -= dx;
+ old_focus_rect->y -= dy;
+
+ new_parent_window = gdk_window_get_parent (new_parent_window);
+ }
+
+ return TRUE;
}
- else
+
+ return FALSE;
+}
+
+typedef struct _CompareInfo CompareInfo;
+
+struct _CompareInfo
+{
+ gint x;
+ gint y;
+};
+
+static gint
+up_down_compare (gconstpointer a,
+ gconstpointer b,
+ gpointer data)
+{
+ const GtkWidget *child1 = a;
+ const GtkWidget *child2 = b;
+ CompareInfo *compare = data;
+
+ gint y1 = child1->allocation.y + child1->allocation.height / 2;
+ gint y2 = child2->allocation.y + child2->allocation.height / 2;
+
+ if (y1 == y2)
{
- focus_width = GTK_WIDGET (container)->allocation.width;
- if (GTK_WIDGET_NO_WINDOW (container))
- focus_x = GTK_WIDGET (container)->allocation.x;
+ gint x1 = abs (child1->allocation.x + child1->allocation.width / 2 - compare->x);
+ gint x2 = abs (child2->allocation.x + child2->allocation.width / 2 - compare->x);
+
+ if (compare->y < y1)
+ return (x1 < x2) ? -1 : ((x1 == x2) ? 0 : 1);
else
- focus_x = 0;
+ return (x1 < x2) ? 1 : ((x1 == x2) ? 0 : -1);
}
+ else
+ return (y1 < y2) ? -1 : 1;
+}
- length = g_list_length (children);
+static gboolean
+gtk_container_focus_up_down (GtkContainer *container,
+ GList **children,
+ GtkDirectionType direction)
+{
+ CompareInfo compare;
+ GList *tmp_list;
- /* sort the children in the y direction */
- for (i = 1; i < length; i++)
+ if (container->focus_child)
{
- j = i;
- tmp_list = g_list_nth (children, j);
- child = tmp_list->data;
+ gint compare_x1;
+ gint compare_x2;
+ gint compare_y;
+
+ /* Delete widgets from list that don't match minimum criteria */
- while (j > 0)
+ compare_x1 = container->focus_child->allocation.x;
+ compare_x2 = container->focus_child->allocation.x + container->focus_child->allocation.width;
+
+ if (direction == GTK_DIR_UP)
+ compare_y = container->focus_child->allocation.y;
+ else
+ compare_y = container->focus_child->allocation.y + container->focus_child->allocation.height;
+
+ tmp_list = *children;
+ while (tmp_list)
{
- child2 = tmp_list->prev->data;
- if (child->allocation.y < child2->allocation.y)
+ GtkWidget *child = tmp_list->data;
+ GList *next = tmp_list->next;
+ gint child_x1, child_x2;
+
+ if (child != container->focus_child)
{
- tmp_list->data = tmp_list->prev->data;
- tmp_list = tmp_list->prev;
- j--;
+ child_x1 = child->allocation.x;
+ child_x2 = child->allocation.x + child->allocation.width;
+
+ if ((child_x2 <= compare_x1 || child_x1 >= compare_x2) /* No horizontal overlap */ ||
+ (direction == GTK_DIR_DOWN && child->allocation.y + child->allocation.height < compare_y) || /* Not below */
+ (direction == GTK_DIR_UP && child->allocation.y > compare_y)) /* Not above */
+ {
+ *children = g_list_delete_link (*children, tmp_list);
+ }
}
- else
- break;
+
+ tmp_list = next;
}
- tmp_list->data = child;
+ compare.x = (compare_x1 + compare_x2) / 2;
+ compare.y = container->focus_child->allocation.y + container->focus_child->allocation.height / 2;
}
-
- /* sort the children in distance in the x direction
- * in distance from the current focus child while maintaining the
- * sort in the y direction
- */
- for (i = 1; i < length; i++)
+ else
{
- j = i;
- tmp_list = g_list_nth (children, j);
- child = tmp_list->data;
- dist1 = (child->allocation.x + child->allocation.width / 2) - focus_x;
+ /* No old focus widget, need to figure out starting x,y some other way
+ */
+ GtkWidget *widget = GTK_WIDGET (container);
+ GdkRectangle old_focus_rect;
- while (j > 0)
+ if (old_focus_coords (container, &old_focus_rect))
{
- child2 = tmp_list->prev->data;
- dist2 = (child2->allocation.x + child2->allocation.width / 2) - focus_x;
-
- if ((dist1 < dist2) &&
- (child->allocation.y >= child2->allocation.y))
- {
- tmp_list->data = tmp_list->prev->data;
- tmp_list = tmp_list->prev;
- j--;
- }
+ compare.x = old_focus_rect.x + old_focus_rect.width / 2;
+ }
+ else
+ {
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ compare.x = widget->allocation.x + widget->allocation.width / 2;
else
- break;
+ compare.x = widget->allocation.width / 2;
}
-
- tmp_list->data = child;
+
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ compare.y = (direction == GTK_DIR_DOWN) ? widget->allocation.y : widget->allocation.y + widget->allocation.height;
+ else
+ compare.y = (direction == GTK_DIR_DOWN) ? 0 : + widget->allocation.height;
}
- /* go and invalidate any widget which is too
- * far from the focus widget.
- */
- if (!container->focus_child &&
- (direction == GTK_DIR_UP))
- focus_x += focus_width;
+ *children = g_list_sort_with_data (*children, up_down_compare, &compare);
- tmp_list = children;
- while (tmp_list)
- {
- child = tmp_list->data;
+ if (direction == GTK_DIR_UP)
+ *children = g_list_reverse (*children);
- dist1 = (child->allocation.x + child->allocation.width / 2) - focus_x;
- if (((direction == GTK_DIR_DOWN) && (dist1 < 0)) ||
- ((direction == GTK_DIR_UP) && (dist1 > 0)))
- tmp_list->data = NULL;
+ return gtk_container_focus_move (container, *children, direction);
+}
- tmp_list = tmp_list->next;
- }
+static gint
+left_right_compare (gconstpointer a,
+ gconstpointer b,
+ gpointer data)
+{
+ const GtkWidget *child1 = a;
+ const GtkWidget *child2 = b;
+ CompareInfo *compare = data;
- if (direction == GTK_DIR_UP)
- children = g_list_reverse (children);
+ gint x1 = child1->allocation.x + child1->allocation.width / 2;
+ gint x2 = child2->allocation.x + child2->allocation.width / 2;
- return gtk_container_focus_move (container, children, direction);
+ if (x1 == x2)
+ {
+ gint y1 = abs (child1->allocation.y + child1->allocation.height / 2 - compare->y);
+ gint y2 = abs (child2->allocation.y + child2->allocation.height / 2 - compare->y);
+
+ if (compare->x < x1)
+ return (y1 < y2) ? -1 : ((y1 == y2) ? 0 : 1);
+ else
+ return (y1 < y2) ? 1 : ((y1 == y2) ? 0 : -1);
+ }
+ else
+ return (x1 < x2) ? -1 : 1;
}
-static gint
+static gboolean
gtk_container_focus_left_right (GtkContainer *container,
- GList *children,
+ GList **children,
GtkDirectionType direction)
{
- GtkWidget *child;
- GtkWidget *child2;
+ CompareInfo compare;
GList *tmp_list;
- gint dist1, dist2;
- gint focus_y;
- gint focus_height;
- guint length;
- guint i, j;
- /* return failure if there isn't a focus child */
if (container->focus_child)
{
- focus_height = container->focus_child->allocation.height / 2;
- focus_y = container->focus_child->allocation.y + focus_height;
- }
- else
- {
- focus_height = GTK_WIDGET (container)->allocation.height;
- if (GTK_WIDGET_NO_WINDOW (container))
- focus_y = GTK_WIDGET (container)->allocation.y;
- else
- focus_y = 0;
- }
+ gint compare_y1;
+ gint compare_y2;
+ gint compare_x;
+
+ /* Delete widgets from list that don't match minimum criteria */
- length = g_list_length (children);
+ compare_y1 = container->focus_child->allocation.y;
+ compare_y2 = container->focus_child->allocation.y + container->focus_child->allocation.height;
- /* sort the children in the x direction */
- for (i = 1; i < length; i++)
- {
- j = i;
- tmp_list = g_list_nth (children, j);
- child = tmp_list->data;
-
- while (j > 0)
+ if (direction == GTK_DIR_LEFT)
+ compare_x = container->focus_child->allocation.x;
+ else
+ compare_x = container->focus_child->allocation.x + container->focus_child->allocation.width;
+
+ tmp_list = *children;
+ while (tmp_list)
{
- child2 = tmp_list->prev->data;
- if (child->allocation.x < child2->allocation.x)
+ GtkWidget *child = tmp_list->data;
+ GList *next = tmp_list->next;
+ gint child_y1, child_y2;
+
+ if (child != container->focus_child)
{
- tmp_list->data = tmp_list->prev->data;
- tmp_list = tmp_list->prev;
- j--;
+ child_y1 = child->allocation.y;
+ child_y2 = child->allocation.y + child->allocation.height;
+
+ if ((child_y2 <= compare_y1 || child_y1 >= compare_y2) /* No vertical overlap */ ||
+ (direction == GTK_DIR_RIGHT && child->allocation.x + child->allocation.width < compare_x) || /* Not to left */
+ (direction == GTK_DIR_LEFT && child->allocation.x > compare_x)) /* Not to right */
+ {
+ *children = g_list_delete_link (*children, tmp_list);
+ }
}
- else
- break;
+
+ tmp_list = next;
}
- tmp_list->data = child;
+ compare.y = (compare_y1 + compare_y2) / 2;
+ compare.x = container->focus_child->allocation.x + container->focus_child->allocation.width / 2;
}
-
- /* sort the children in distance in the y direction
- * in distance from the current focus child while maintaining the
- * sort in the x direction
- */
- for (i = 1; i < length; i++)
+ else
{
- j = i;
- tmp_list = g_list_nth (children, j);
- child = tmp_list->data;
- dist1 = (child->allocation.y + child->allocation.height / 2) - focus_y;
+ /* No old focus widget, need to figure out starting x,y some other way
+ */
+ GtkWidget *widget = GTK_WIDGET (container);
+ GdkRectangle old_focus_rect;
- while (j > 0)
+ if (old_focus_coords (container, &old_focus_rect))
{
- child2 = tmp_list->prev->data;
- dist2 = (child2->allocation.y + child2->allocation.height / 2) - focus_y;
-
- if ((dist1 < dist2) &&
- (child->allocation.x >= child2->allocation.x))
- {
- tmp_list->data = tmp_list->prev->data;
- tmp_list = tmp_list->prev;
- j--;
- }
+ compare.y = old_focus_rect.y + old_focus_rect.height / 2;
+ }
+ else
+ {
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ compare.y = widget->allocation.y + widget->allocation.height / 2;
else
- break;
+ compare.y = widget->allocation.height / 2;
}
-
- tmp_list->data = child;
+
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ compare.x = (direction == GTK_DIR_RIGHT) ? widget->allocation.x : widget->allocation.x + widget->allocation.width;
+ else
+ compare.x = (direction == GTK_DIR_RIGHT) ? 0 : widget->allocation.width;
}
- /* go and invalidate any widget which is too
- * far from the focus widget.
- */
- if (!container->focus_child &&
- (direction == GTK_DIR_LEFT))
- focus_y += focus_height;
-
- tmp_list = children;
- while (tmp_list)
- {
- child = tmp_list->data;
-
- dist1 = (child->allocation.y + child->allocation.height / 2) - focus_y;
- if (((direction == GTK_DIR_RIGHT) && (dist1 < 0)) ||
- ((direction == GTK_DIR_LEFT) && (dist1 > 0)))
- tmp_list->data = NULL;
-
- tmp_list = tmp_list->next;
- }
+ *children = g_list_sort_with_data (*children, left_right_compare, &compare);
if (direction == GTK_DIR_LEFT)
- children = g_list_reverse (children);
+ *children = g_list_reverse (*children);
- return gtk_container_focus_move (container, children, direction);
+ return gtk_container_focus_move (container, *children, direction);
}
-static gint
+static gboolean
gtk_container_focus_move (GtkContainer *container,
GList *children,
GtkDirectionType direction)
GtkWidget *child;
focus_child = container->focus_child;
- gtk_container_set_focus_child (container, NULL);
while (children)
{
focus_child = NULL;
if (GTK_WIDGET_DRAWABLE (child) &&
- GTK_IS_CONTAINER (child) &&
- !GTK_WIDGET_HAS_FOCUS (child))
+ GTK_IS_CONTAINER (child))
if (gtk_container_focus (GTK_CONTAINER (child), direction))
return TRUE;
}
gboolean include_internals,
GtkCallback callback,
gpointer callbabck_data);
- gint (* focus) (GtkContainer *container,
+ gboolean (* focus) (GtkContainer *container,
GtkDirectionType direction);
void (* set_focus_child) (GtkContainer *container,
GtkWidget *widget);
void gtk_container_check_resize (GtkContainer *container);
-void gtk_container_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data);
-void gtk_container_foreach_full (GtkContainer *container,
- GtkCallback callback,
- GtkCallbackMarshal marshal,
- gpointer callback_data,
- GtkDestroyNotify notify);
-GList* gtk_container_children (GtkContainer *container);
-gint gtk_container_focus (GtkContainer *container,
- GtkDirectionType direction);
+void gtk_container_foreach (GtkContainer *container,
+ GtkCallback callback,
+ gpointer callback_data);
+void gtk_container_foreach_full (GtkContainer *container,
+ GtkCallback callback,
+ GtkCallbackMarshal marshal,
+ gpointer callback_data,
+ GtkDestroyNotify notify);
+GList* gtk_container_children (GtkContainer *container);
+gboolean gtk_container_focus (GtkContainer *container,
+ GtkDirectionType direction);
/* Widget-level methods */
CHILD_ARG_TAB_PACK
};
+#define GTK_NOTEBOOK_PAGE(_glist_) ((GtkNotebookPage *)((GList *)(_glist_))->data)
+
+struct _GtkNotebookPage
+{
+ GtkWidget *child;
+ GtkWidget *tab_label;
+ GtkWidget *menu_label;
+
+ guint default_menu : 1; /* If true, we create the menu label ourself */
+ guint default_tab : 1; /* If true, we create the tab label ourself */
+ guint expand : 1;
+ guint fill : 1;
+ guint pack : 1;
+
+ GtkRequisition requisition;
+ GtkAllocation allocation;
+};
+
+#ifdef G_DISABLE_CHECKS
+#define CHECK_FIND_CHILD(notebook, child) \
+ gtk_notebook_find_child(notebook, child, \
+ G_GNUC_PRETTY_FUNCTION)
+#else
+#define CHECK_FIND_CHILD(notebook, child) \
+ gtk_notebook_find_child(notebook, child, NULL)
+#endif
+
/*** GtkNotebook Methods ***/
static void gtk_notebook_class_init (GtkNotebookClass *klass);
static void gtk_notebook_init (GtkNotebook *notebook);
/*** GtkNotebook Private Functions ***/
static void gtk_notebook_panel_realize (GtkNotebook *notebook);
-static void gtk_notebook_expose_tabs (GtkNotebook *notebook);
+static void gtk_notebook_redraw_tabs (GtkNotebook *notebook);
+static void gtk_notebook_redraw_arrows (GtkNotebook *notebook);
static void gtk_notebook_focus_changed (GtkNotebook *notebook,
GtkNotebookPage *old_page);
static void gtk_notebook_real_remove (GtkNotebook *notebook,
static gint gtk_notebook_timer (GtkNotebook *notebook);
static gint gtk_notebook_page_compare (gconstpointer a,
gconstpointer b);
+static GList *gtk_notebook_find_child (GtkNotebook *notebook,
+ GtkWidget *child,
+ const gchar *function);
static gint gtk_notebook_real_page_position (GtkNotebook *notebook,
GList *list);
static GList * gtk_notebook_search_page (GtkNotebook *notebook,
static void gtk_notebook_set_shape (GtkNotebook *notebook);
/*** GtkNotebook Size Allocate Functions ***/
-static void gtk_notebook_pages_allocate (GtkNotebook *notebook,
- GtkAllocation *allocation);
+static void gtk_notebook_pages_allocate (GtkNotebook *notebook);
static void gtk_notebook_page_allocate (GtkNotebook *notebook,
GtkNotebookPage *page,
GtkAllocation *allocation);
static void gtk_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
gint page_num);
-static gint gtk_notebook_page_select (GtkNotebook *notebook);
+static gint gtk_notebook_page_select (GtkNotebook *notebook,
+ gboolean move_focus);
static void gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
GList *new_child);
static void gtk_notebook_menu_switch_page (GtkWidget *widget,
static void
gtk_notebook_init (GtkNotebook *notebook)
{
- GTK_WIDGET_SET_FLAGS (notebook, GTK_CAN_FOCUS);
+ GTK_WIDGET_SET_FLAGS (notebook, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT);
GTK_WIDGET_UNSET_FLAGS (notebook, GTK_NO_WINDOW);
notebook->cur_page = NULL;
notebook->have_visible_child = FALSE;
}
+/**
+ * gtk_notebook_new:
+ * @void:
+ *
+ * Creates a new #GtkNotebook widget with no pages.
+
+ * Return value: the newly created #GtkNotebook
+ **/
GtkWidget*
gtk_notebook_new (void)
{
gtk_widget_map (notebook->cur_page->child);
if (notebook->scrollable)
- gtk_notebook_pages_allocate (notebook, &(widget->allocation));
+ gtk_notebook_pages_allocate (notebook);
else
{
children = notebook->children;
gtk_widget_size_allocate (page->child, &child_allocation);
}
- gtk_notebook_pages_allocate (notebook, allocation);
+ gtk_notebook_pages_allocate (notebook);
}
gtk_notebook_set_shape (notebook);
}
return FALSE;
}
-static gint
+static gboolean
+gtk_notebook_arrow_button_press (GtkNotebook *notebook,
+ GdkEventButton *event)
+{
+ GtkWidget *widget = GTK_WIDGET (notebook);
+
+ GtkArrowType arrow = event->x <= ARROW_SIZE + ARROW_SPACING / 2 ? GTK_ARROW_LEFT : GTK_ARROW_RIGHT;
+
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_widget_grab_focus (widget);
+
+ notebook->button = event->button;
+ notebook->click_child = arrow;
+
+ if (event->button == 1)
+ {
+ if (!notebook->focus_tab ||
+ gtk_notebook_search_page (notebook, notebook->focus_tab,
+ arrow == GTK_ARROW_LEFT ? STEP_PREV : STEP_NEXT,
+ TRUE))
+ gtk_container_focus (GTK_CONTAINER (notebook),
+ arrow == GTK_ARROW_LEFT ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
+
+ if (!notebook->timer)
+ {
+ notebook->timer = gtk_timeout_add
+ (NOTEBOOK_INIT_SCROLL_DELAY,
+ (GtkFunction) gtk_notebook_timer, (gpointer) notebook);
+ notebook->need_timer = TRUE;
+ }
+ }
+ else if (event->button == 2)
+ gtk_notebook_page_select (notebook, TRUE);
+ else if (event->button == 3)
+ gtk_notebook_switch_focus_tab (notebook,
+ gtk_notebook_search_page (notebook,
+ NULL,
+ arrow == GTK_ARROW_LEFT ? STEP_NEXT : STEP_PREV,
+ TRUE));
+ gtk_notebook_redraw_arrows (notebook);
+
+ return TRUE;
+}
+
+static gboolean
gtk_notebook_button_press (GtkWidget *widget,
GdkEventButton *event)
{
if (event->window == notebook->panel)
{
- if (!GTK_WIDGET_HAS_FOCUS (widget))
- gtk_widget_grab_focus (widget);
-
- gtk_grab_add (widget);
- notebook->button = event->button;
-
- if (event->x <= ARROW_SIZE + ARROW_SPACING / 2)
- {
- notebook->click_child = GTK_ARROW_LEFT;
- if (event->button == 1)
- {
- if (!notebook->focus_tab ||
- gtk_notebook_search_page (notebook, notebook->focus_tab,
- STEP_PREV, TRUE))
- gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_LEFT);
-
- if (!notebook->timer)
- {
- notebook->timer = gtk_timeout_add
- (NOTEBOOK_INIT_SCROLL_DELAY,
- (GtkFunction) gtk_notebook_timer, (gpointer) notebook);
- notebook->need_timer = TRUE;
- }
- }
- else if (event->button == 2)
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
- else if (event->button == 3)
- gtk_notebook_switch_focus_tab (notebook,
- gtk_notebook_search_page (notebook,
- NULL,
- STEP_NEXT,
- TRUE));
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
- }
- else
- {
- notebook->click_child = GTK_ARROW_RIGHT;
- if (event->button == 1)
- {
- if (!notebook->focus_tab ||
- gtk_notebook_search_page (notebook, notebook->focus_tab,
- STEP_NEXT, TRUE))
- gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_RIGHT);
-
- if (!notebook->timer)
- {
- notebook->timer = gtk_timeout_add
- (NOTEBOOK_INIT_SCROLL_DELAY,
- (GtkFunction) gtk_notebook_timer, (gpointer) notebook);
- notebook->need_timer = TRUE;
- }
- }
- else if (event->button == 2)
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
- else if (event->button == 3)
- gtk_notebook_switch_focus_tab
- (notebook, gtk_notebook_search_page (notebook, NULL,
- STEP_PREV, TRUE));
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
- }
+ return gtk_notebook_arrow_button_press (notebook, event);
}
else if (event->window == widget->window)
{
{
gtk_menu_popup (GTK_MENU (notebook->menu), NULL, NULL,
NULL, NULL, 3, event->time);
- return FALSE;
+ return TRUE;
}
num = 0;
if (!children && !GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
}
- gtk_notebook_set_shape (notebook);
- return FALSE;
+
+ return TRUE;
}
static gint
notebook->timer = 0;
notebook->need_timer = FALSE;
}
- gtk_grab_remove (widget);
click_child = notebook->click_child;
notebook->click_child = 0;
notebook->button = 0;
- gtk_notebook_draw_arrow (notebook, click_child);
+ gtk_notebook_redraw_arrows (notebook);
}
return FALSE;
gdk_window_get_pointer (notebook->panel, &x, &y, NULL);
if (x <= ARROW_SIZE + ARROW_SPACING / 2)
- {
- notebook->in_child = GTK_ARROW_LEFT;
-
- if (notebook->click_child == 0)
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
- }
- else
- {
- notebook->in_child = GTK_ARROW_RIGHT;
+ notebook->in_child = GTK_ARROW_LEFT;
+ else
+ notebook->in_child = GTK_ARROW_RIGHT;
- if (notebook->click_child == 0)
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
- }
+ gtk_notebook_redraw_arrows (notebook);
}
return FALSE;
notebook = GTK_NOTEBOOK (widget);
- if (event->window == notebook->panel && !notebook->click_child)
- {
- if (notebook->in_child == GTK_ARROW_LEFT)
- {
- notebook->in_child = 0;
- gtk_notebook_draw_arrow (notebook,GTK_ARROW_LEFT);
- }
- else
- {
- notebook->in_child = 0;
- gtk_notebook_draw_arrow (notebook,GTK_ARROW_RIGHT);
- }
- }
+ if (event->window == notebook->panel)
+ gtk_notebook_redraw_arrows (notebook);
+
return FALSE;
}
if (event->window == notebook->panel)
{
gint x;
+ GtkArrowType old_child = notebook->in_child;
x = event->x;
if (event->is_hint)
gdk_window_get_pointer (notebook->panel, &x, NULL, NULL);
- if (x <= ARROW_SIZE + ARROW_SPACING / 2 &&
- notebook->in_child == GTK_ARROW_RIGHT)
- {
- notebook->in_child = GTK_ARROW_LEFT;
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
- }
- else if (x > ARROW_SIZE + ARROW_SPACING / 2 &&
- notebook->in_child == GTK_ARROW_LEFT)
- {
- notebook->in_child = GTK_ARROW_RIGHT;
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
- }
- return FALSE;
+ if (x <= ARROW_SIZE + ARROW_SPACING / 2)
+ notebook->in_child = GTK_ARROW_LEFT;
+ else
+ notebook->in_child = GTK_ARROW_RIGHT;
+
+ if (old_child != notebook->in_child)
+ gtk_notebook_redraw_arrows (notebook);
}
+
return FALSE;
}
GdkEventKey *event)
{
GtkNotebook *notebook;
- GtkDirectionType direction = 0;
GList *list;
g_return_val_if_fail (widget != NULL, FALSE);
switch (event->keyval)
{
- case GDK_Up:
- switch (notebook->tab_pos)
- {
- case GTK_POS_BOTTOM:
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
- return TRUE;
- case GTK_POS_TOP:
- return FALSE;
- default:
- direction = GTK_DIR_UP;
- break;
- }
- break;
- case GDK_Left:
- switch (notebook->tab_pos)
- {
- case GTK_POS_RIGHT:
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
- return TRUE;
- case GTK_POS_LEFT:
- return FALSE;
- default:
- direction = GTK_DIR_LEFT;
- break;
- }
- break;
- case GDK_Down:
- switch (notebook->tab_pos)
- {
- case GTK_POS_TOP:
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
- return TRUE;
- case GTK_POS_BOTTOM:
- return FALSE;
- default:
- direction = GTK_DIR_DOWN;
- break;
- }
- break;
- case GDK_Right:
- switch (notebook->tab_pos)
- {
- case GTK_POS_LEFT:
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
- return TRUE;
- case GTK_POS_RIGHT:
- return FALSE;
- default:
- direction = GTK_DIR_RIGHT;
- break;
- }
- break;
- case GDK_Tab:
- case GDK_ISO_Left_Tab:
- if (event->state & GDK_SHIFT_MASK)
- direction = GTK_DIR_TAB_BACKWARD;
- else
- direction = GTK_DIR_TAB_FORWARD;
- break;
case GDK_Home:
list = gtk_notebook_search_page (notebook, NULL, STEP_NEXT, TRUE);
if (list)
gtk_notebook_switch_focus_tab (notebook, list);
return TRUE;
case GDK_Return:
+ gtk_notebook_page_select (GTK_NOTEBOOK (widget), TRUE);
+ return TRUE;
case GDK_space:
- gtk_notebook_page_select (GTK_NOTEBOOK (widget));
+ gtk_notebook_page_select (GTK_NOTEBOOK (widget), FALSE);
return TRUE;
- default:
- return FALSE;
}
- return gtk_container_focus (GTK_CONTAINER (widget), direction);
+
+ return FALSE;
}
static gint
notebook = GTK_NOTEBOOK (container);
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
+ arg->type = GTK_TYPE_INVALID;
+
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
{
arg->type = GTK_TYPE_INVALID;
return;
}
}
+static gboolean
+focus_tabs_in (GtkNotebook *notebook)
+{
+ if (notebook->cur_page)
+ {
+ gtk_widget_grab_focus (GTK_WIDGET (notebook));
+
+ gtk_notebook_switch_focus_tab (notebook,
+ g_list_find (notebook->children,
+ notebook->cur_page));
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+static gboolean
+focus_tabs_move (GtkNotebook *notebook,
+ GtkDirectionType direction,
+ gint search_direction)
+{
+ GList *new_page;
+
+ new_page = gtk_notebook_search_page (notebook, notebook->focus_tab,
+ search_direction, TRUE);
+ if (!new_page)
+ new_page = (search_direction == STEP_NEXT) ?
+ notebook->children :
+ g_list_last (notebook->children);
+
+ gtk_notebook_switch_focus_tab (notebook, new_page);
+
+ return TRUE;
+}
+
+static gboolean
+focus_child_in (GtkNotebook *notebook,
+ GtkDirectionType direction)
+{
+ if (GTK_WIDGET_DRAWABLE (notebook->cur_page->child) &&
+ GTK_WIDGET_IS_SENSITIVE (notebook->cur_page->child))
+ {
+ if (GTK_IS_CONTAINER (notebook->cur_page->child))
+ {
+ if (gtk_container_focus (GTK_CONTAINER (notebook->cur_page->child), direction))
+ return TRUE;
+ }
+ else if (GTK_WIDGET_CAN_FOCUS (notebook->cur_page->child))
+ {
+ gtk_widget_grab_focus (notebook->cur_page->child);
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/* Focus in the notebook can either be on the pages, or on
+ * the tabs.
+ */
static gint
gtk_notebook_focus (GtkContainer *container,
GtkDirectionType direction)
{
+ GtkWidget *old_focus_child;
GtkNotebook *notebook;
- GtkNotebookPage *page = NULL;
- GtkNotebookPage *old_page = NULL;
+ GtkDirectionType effective_direction;
+
+ /* Remap the directions into the effective direction it would be for a
+ * GTK_POS_TOP notebook
+ */
+#define D(rest) GTK_DIR_##rest
+
+ static const GtkDirectionType translate_direction[4][6] = {
+ /* LEFT */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(LEFT), D(RIGHT), D(UP), D(DOWN) },
+ /* RIGHT */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(LEFT), D(RIGHT), D(DOWN), D(UP) },
+ /* TOP */ { D(TAB_FORWARD), D(TAB_BACKWARD), D(UP), D(DOWN), D(LEFT), D(RIGHT) },
+ /* BOTTOM */ { D(TAB_BACKWARD), D(TAB_FORWARD), D(DOWN), D(UP), D(LEFT), D(RIGHT) },
+ };
+
+#undef D
+
+ gboolean widget_is_focus;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_NOTEBOOK (container), FALSE);
notebook = GTK_NOTEBOOK (container);
- if (!GTK_WIDGET_DRAWABLE (notebook) ||
- !GTK_WIDGET_IS_SENSITIVE (container) ||
- !notebook->children ||
- !notebook->cur_page)
- return FALSE;
+ widget_is_focus = gtk_widget_is_focus (GTK_WIDGET (container));
+ old_focus_child = container->focus_child;
- if (!notebook->show_tabs)
- {
- if (GTK_WIDGET_DRAWABLE (notebook->cur_page->child) &&
- GTK_WIDGET_IS_SENSITIVE (notebook->cur_page->child))
- {
- if (GTK_IS_CONTAINER (notebook->cur_page->child))
- {
- if (gtk_container_focus
- (GTK_CONTAINER (notebook->cur_page->child), direction))
- return TRUE;
- }
- else if (GTK_WIDGET_CAN_FOCUS (notebook->cur_page->child))
- {
- if (!container->focus_child)
- {
- gtk_widget_grab_focus (notebook->cur_page->child);
- return TRUE;
- }
- }
- }
- return FALSE;
- }
+ effective_direction = translate_direction[notebook->tab_pos][direction];
- if (notebook->focus_tab)
- old_page = notebook->focus_tab->data;
+ if (old_focus_child &&
+ GTK_IS_CONTAINER (old_focus_child) &&
+ GTK_WIDGET_DRAWABLE (old_focus_child) &&
+ GTK_WIDGET_IS_SENSITIVE (old_focus_child) &&
+ gtk_container_focus (GTK_CONTAINER (old_focus_child), direction))
+ return TRUE;
- if (container->focus_child && old_page &&
- container->focus_child == old_page->child && notebook->child_has_focus)
+ if (old_focus_child) /* Focus on page child */
{
- if (GTK_WIDGET_DRAWABLE (container->focus_child))
+ switch (effective_direction)
{
- if (GTK_IS_CONTAINER (container->focus_child) &&
- !GTK_WIDGET_HAS_FOCUS (container->focus_child))
- {
- if (gtk_container_focus (GTK_CONTAINER (container->focus_child),
- direction))
- return TRUE;
- }
- gtk_widget_grab_focus (GTK_WIDGET(notebook));
- return TRUE;
+ case GTK_DIR_TAB_BACKWARD:
+ case GTK_DIR_UP:
+ /* Focus onto the tabs */
+ if (notebook->show_tabs)
+ return focus_tabs_in (notebook);
+ else
+ return FALSE;
+ case GTK_DIR_DOWN:
+ case GTK_DIR_TAB_FORWARD:
+ case GTK_DIR_LEFT:
+ case GTK_DIR_RIGHT:
+ return FALSE;
}
- notebook->focus_tab = NULL;
- return FALSE;
}
-
- if (!GTK_WIDGET_HAS_FOCUS (container))
- notebook->focus_tab = NULL;
-
- switch (direction)
+ else if (widget_is_focus) /* Focus was on tabs */
{
- case GTK_DIR_TAB_FORWARD:
- case GTK_DIR_RIGHT:
- case GTK_DIR_DOWN:
- gtk_notebook_switch_focus_tab
- (notebook, gtk_notebook_search_page (notebook, notebook->focus_tab,
- STEP_NEXT, TRUE));
- break;
- case GTK_DIR_TAB_BACKWARD:
- case GTK_DIR_LEFT:
- case GTK_DIR_UP:
- gtk_notebook_switch_focus_tab
- (notebook, gtk_notebook_search_page (notebook, notebook->focus_tab,
- STEP_PREV, TRUE));
- break;
+ switch (effective_direction)
+ {
+ case GTK_DIR_TAB_BACKWARD:
+ case GTK_DIR_UP:
+ return FALSE;
+ case GTK_DIR_TAB_FORWARD:
+ case GTK_DIR_DOWN:
+ return focus_child_in (notebook, direction);
+ case GTK_DIR_LEFT:
+ return focus_tabs_move (notebook, direction, STEP_PREV);
+ case GTK_DIR_RIGHT:
+ return focus_tabs_move (notebook, direction, STEP_NEXT);
+ }
}
-
- if (notebook->focus_tab)
+ else /* Focus was not on widget */
{
- if (!GTK_WIDGET_HAS_FOCUS (container))
- gtk_widget_grab_focus (GTK_WIDGET (container));
-
- page = notebook->focus_tab->data;
- if (GTK_WIDGET_MAPPED (page->tab_label))
- gtk_notebook_focus_changed (notebook, old_page);
- else
+ switch (effective_direction)
{
- gtk_notebook_pages_allocate (notebook,
- &(GTK_WIDGET (notebook)->allocation));
- gtk_notebook_expose_tabs (notebook);
+ case GTK_DIR_TAB_FORWARD:
+ case GTK_DIR_DOWN:
+ if (focus_tabs_in (notebook))
+ return TRUE;
+ if (focus_child_in (notebook, direction))
+ return TRUE;
+ return FALSE;
+ case GTK_DIR_TAB_BACKWARD:
+ case GTK_DIR_UP:
+ if (focus_child_in (notebook, direction))
+ return TRUE;
+ if (focus_tabs_in (notebook))
+ return TRUE;
+ return FALSE;
+ case GTK_DIR_LEFT:
+ case GTK_DIR_RIGHT:
+ return focus_child_in (notebook, direction);
}
- return TRUE;
}
- gtk_notebook_focus_changed (notebook, old_page);
+ g_assert_not_reached ();
return FALSE;
-}
-
+}
+
static void
gtk_notebook_set_focus_child (GtkContainer *container,
GtkWidget *child)
/* Private GtkNotebook Functions:
*
* gtk_notebook_panel_realize
- * gtk_notebook_expose_tabs
+ * gtk_notebook_redraw_tabs
* gtk_notebook_focus_changed
* gtk_notebook_real_remove
* gtk_notebook_update_labels
}
static void
-gtk_notebook_expose_tabs (GtkNotebook *notebook)
+gtk_notebook_redraw_tabs (GtkNotebook *notebook)
{
GtkWidget *widget;
GtkNotebookPage *page;
- GdkEventExpose event;
+ GdkRectangle redraw_rect;
gint border;
widget = GTK_WIDGET (notebook);
page = notebook->first_tab->data;
- event.type = GDK_EXPOSE;
- event.window = widget->window;
- event.count = 0;
- event.area.x = border;
- event.area.y = border;
+ redraw_rect.x = border;
+ redraw_rect.y = border;
switch (notebook->tab_pos)
{
case GTK_POS_BOTTOM:
- event.area.y = (widget->allocation.height - border -
- page->allocation.height -
- widget->style->ythickness);
+ redraw_rect.y = (widget->allocation.height - border -
+ page->allocation.height -
+ widget->style->ythickness);
if (page != notebook->cur_page)
- event.area.y -= widget->style->ythickness;
+ redraw_rect.y -= widget->style->ythickness;
+ /* fall through */
case GTK_POS_TOP:
- event.area.width = widget->allocation.width - 2 * border;
- event.area.height = (page->allocation.height +
- widget->style->ythickness);
+ redraw_rect.width = widget->allocation.width - 2 * border;
+ redraw_rect.height = (page->allocation.height +
+ widget->style->ythickness);
if (page != notebook->cur_page)
- event.area.height += widget->style->ythickness;
+ redraw_rect.height += widget->style->ythickness;
break;
case GTK_POS_RIGHT:
- event.area.x = (widget->allocation.width - border -
- page->allocation.width -
- widget->style->xthickness);
+ redraw_rect.x = (widget->allocation.width - border -
+ page->allocation.width -
+ widget->style->xthickness);
if (page != notebook->cur_page)
- event.area.x -= widget->style->xthickness;
+ redraw_rect.x -= widget->style->xthickness;
+ /* fall through */
case GTK_POS_LEFT:
- event.area.width = (page->allocation.width +
- widget->style->xthickness);
- event.area.height = widget->allocation.height - 2 * border;
+ redraw_rect.width = (page->allocation.width +
+ widget->style->xthickness);
+ redraw_rect.height = widget->allocation.height - 2 * border;
if (page != notebook->cur_page)
- event.area.width += widget->style->xthickness;
+ redraw_rect.width += widget->style->xthickness;
break;
- }
- gtk_widget_event (widget, (GdkEvent *) &event);
+ }
+
+ gdk_window_invalidate_rect (widget->window, &redraw_rect, TRUE);
+}
+
+static void
+gtk_notebook_redraw_arrows (GtkNotebook *notebook)
+{
+ if (GTK_WIDGET_MAPPED (notebook) && notebook->panel)
+ gdk_window_invalidate_rect (notebook->panel, NULL, FALSE);
}
static void
return (((GtkNotebookPage *) a)->child != b);
}
+static GList *
+gtk_notebook_find_child (GtkNotebook *notebook,
+ GtkWidget *child,
+ const gchar *function)
+{
+ GList *list = g_list_find_custom (notebook->children, child,
+ gtk_notebook_page_compare);
+
+#ifndef G_DISABLE_CHECKS
+ if (!list)
+ g_warning ("child argument to '%s' does not refer to the contents of a notebook page",
+ function);
+#endif
+
+ return list;
+}
+
static void
gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list)
* gtk_notebook_calc_tabs
*/
static void
-gtk_notebook_pages_allocate (GtkNotebook *notebook,
- GtkAllocation *allocation)
+gtk_notebook_pages_allocate (GtkNotebook *notebook)
{
- GtkWidget *widget;
- GtkContainer *container;
+ GtkWidget *widget = GTK_WIDGET (notebook);
+ GtkContainer *container = GTK_CONTAINER (notebook);
GtkNotebookPage *page = NULL;
+ GtkAllocation *allocation = &widget->allocation;
GtkAllocation child_allocation;
GList *children = NULL;
GList *last_child = NULL;
if (!notebook->show_tabs || !notebook->children || !notebook->cur_page)
return;
- widget = GTK_WIDGET (notebook);
- container = GTK_CONTAINER (notebook);
-
child_allocation.x = container->border_width;
child_allocation.y = container->border_width;
child_allocation.y = (allocation->height -
notebook->cur_page->requisition.height -
container->border_width);
+ /* fall through */
case GTK_POS_TOP:
child_allocation.height = notebook->cur_page->requisition.height;
break;
+
case GTK_POS_RIGHT:
child_allocation.x = (allocation->width -
notebook->cur_page->requisition.width -
container->border_width);
+ /* fall through */
case GTK_POS_LEFT:
child_allocation.width = notebook->cur_page->requisition.width;
break;
{
if (children == last_child)
{
- gtk_notebook_set_shape (notebook);
- return;
- children = NULL;
- break;
+ /* FIXME double check */
+ goto done;
}
page = children->data;
}
}
}
+
+ done:
gtk_notebook_set_shape (notebook);
+ gtk_notebook_redraw_tabs (notebook);
}
static void
}
static gint
-gtk_notebook_page_select (GtkNotebook *notebook)
+gtk_notebook_page_select (GtkNotebook *notebook,
+ gboolean move_focus)
{
GtkNotebookPage *page;
+ GtkDirectionType dir = GTK_DIR_DOWN; /* Quiet GCC */
g_return_val_if_fail (notebook != NULL, FALSE);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), FALSE);
page = notebook->focus_tab->data;
gtk_notebook_switch_page (notebook, page, -1);
- if (GTK_WIDGET_VISIBLE (page->child))
+ if (move_focus)
{
- if (GTK_IS_CONTAINER (page->child))
+ switch (notebook->tab_pos)
{
- if (gtk_container_focus (GTK_CONTAINER (page->child),
- GTK_DIR_TAB_FORWARD))
- return TRUE;
+ case GTK_POS_TOP:
+ dir = GTK_DIR_DOWN;
+ break;
+ case GTK_POS_BOTTOM:
+ dir = GTK_DIR_UP;
+ break;
+ case GTK_POS_LEFT:
+ dir = GTK_DIR_RIGHT;
+ break;
+ case GTK_POS_RIGHT:
+ dir = GTK_DIR_LEFT;
+ break;
}
- else if (GTK_WIDGET_CAN_FOCUS (page->child))
+
+ if (GTK_WIDGET_VISIBLE (page->child))
{
- gtk_widget_grab_focus (page->child);
- return TRUE;
+ if (GTK_IS_CONTAINER (page->child))
+ {
+ if (gtk_container_focus (GTK_CONTAINER (page->child),
+ dir))
+ return TRUE;
+ }
+ else if (GTK_WIDGET_CAN_FOCUS (page->child))
+ {
+ gtk_widget_grab_focus (page->child);
+ return TRUE;
+ }
}
}
return FALSE;
notebook->focus_tab = new_child;
if (notebook->scrollable && GTK_WIDGET_DRAWABLE (notebook))
- {
- if ((new_child == NULL) != (old_child == NULL))
- {
- gdk_window_clear (notebook->panel);
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
- }
- else
- {
- GList *olist;
- GList *nlist;
-
- olist = gtk_notebook_search_page (notebook, old_child,
- STEP_PREV, TRUE);
- nlist = gtk_notebook_search_page (notebook, new_child,
- STEP_PREV, TRUE);
-
- if ((olist == NULL) != (nlist == NULL))
- {
- gdk_window_clear_area (notebook->panel, 0, 0,
- ARROW_SIZE, ARROW_SIZE);
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_LEFT);
- }
-
- olist = gtk_notebook_search_page (notebook, old_child,
- STEP_NEXT, TRUE);
- nlist = gtk_notebook_search_page (notebook, new_child,
- STEP_NEXT, TRUE);
-
- if ((olist == NULL) != (nlist == NULL))
- {
- gdk_window_clear_area (notebook->panel,
- ARROW_SIZE + ARROW_SPACING, 0,
- ARROW_SIZE, ARROW_SIZE);
- gtk_notebook_draw_arrow (notebook, GTK_ARROW_RIGHT);
- }
- }
- }
+ gtk_notebook_redraw_arrows (notebook);
if (!notebook->show_tabs || !notebook->focus_tab)
return;
if (GTK_WIDGET_MAPPED (page->tab_label))
gtk_notebook_focus_changed (notebook, old_page);
else
- {
- gtk_notebook_pages_allocate (notebook,
- &(GTK_WIDGET (notebook)->allocation));
- gtk_notebook_expose_tabs (notebook);
- }
+ gtk_notebook_pages_allocate (notebook);
gtk_notebook_set_shape (notebook);
}
* gtk_notebook_insert_page_menu
* gtk_notebook_remove_page
*/
+/**
+ * gtk_notebook_append_page:
+ * @notebook: a #GtkNotebook
+ * @child: the #GtkWidget to use as the contents of the page.
+ * @tab_label: the #GtkWidget to be used as the label for the page,
+ * or %NULL to use the default label, 'page N'.
+ *
+ * Appends a page to @notebook.
+ **/
void
gtk_notebook_append_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label)
{
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
+
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, -1);
}
+/**
+ * gtk_notebook_append_page_menu:
+ * @notebook: a #GtkNotebook
+ * @child: the #GtkWidget to use as the contents of the page.
+ * @tab_label: the #GtkWidget to be used as the label for the page,
+ * or %NULL to use the default label, 'page N'.
+ * @menu_label: the widget to use as a label for the page-switch
+ * menu, if that is enabled. If %NULL, and @tab_label
+ * is a #GtkLabel or %NULL, then the menu label will be
+ * a newly created label with the same text as @tab_label;
+ * If @tab_label is not a #GtkLabel, @menu_label must be
+ * specified if the page-switch menu is to be used.
+ *
+ * Appends a page to @notebook, specifying the widget to use as the
+ * label in the popup menu.
+ **/
void
gtk_notebook_append_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label)
{
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
+ g_return_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label));
+
gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, -1);
}
+/**
+ * gtk_notebook_prepend_page:
+ * @notebook: a #GtkNotebook
+ * @child: the #GtkWidget to use as the contents of the page.
+ * @tab_label: the #GtkWidget to be used as the label for the page,
+ * or %NULL to use the default label, 'page N'.
+ *
+ * Prepends a page to @noteobook.
+ **/
void
gtk_notebook_prepend_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label)
{
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
+
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, 0);
}
+/**
+ * gtk_notebook_prepend_page_menu:
+ * @notebook: a #GtkNotebook
+ * @child: the #GtkWidget to use as the contents of the page.
+ * @tab_label: the #GtkWidget to be used as the label for the page,
+ * or %NULL to use the default label, 'page N'.
+ * @menu_label: the widget to use as a label for the page-switch
+ * menu, if that is enabled. If %NULL, and @tab_label
+ * is a #GtkLabel or %NULL, then the menu label will be
+ * a newly created label with the same text as @tab_label;
+ * If @tab_label is not a #GtkLabel, @menu_label must be
+ * specified if the page-switch menu is to be used.
+ *
+ * Prepends a page to @notebook, specifying the widget to use as the
+ * label in the popup menu.
+ **/
void
gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label)
{
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
+ g_return_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label));
+
gtk_notebook_insert_page_menu (notebook, child, tab_label, menu_label, 0);
}
+/**
+ * gtk_notebook_insert_page:
+ * @notebook: a #GtkNotebook
+ * @child: the #GtkWidget to use as the contents of the page.
+ * @tab_label: the #GtkWidget to be used as the label for the page,
+ * or %NULL to use the default label, 'page N'.
+ * @position: the index (starting at 0) at which to insert the page,
+ * or -1 to append the page after all other pages.
+ *
+ * Insert a page into @notebook at the given position
+ **/
void
gtk_notebook_insert_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
gint position)
{
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
+
gtk_notebook_insert_page_menu (notebook, child, tab_label, NULL, position);
}
+/**
+ * gtk_notebook_insert_page_menu:
+ * @notebook: a #GtkNotebook
+ * @child: the #GtkWidget to use as the contents of the page.
+ * @tab_label: the #GtkWidget to be used as the label for the page,
+ * or %NULL to use the default label, 'page N'.
+ * @menu_label: the widget to use as a label for the page-switch
+ * menu, if that is enabled. If %NULL, and @tab_label
+ * is a #GtkLabel or %NULL, then the menu label will be
+ * a newly created label with the same text as @tab_label;
+ * If @tab_label is not a #GtkLabel, @menu_label must be
+ * specified if the page-switch menu is to be used.
+ * @position: the index (starting at 0) at which to insert the page,
+ * or -1 to append the page after all other pages.
+ *
+ * Insert a page into @notebook at the given position, specifying
+ * the widget to use as the label in the popup menu.
+ **/
void
gtk_notebook_insert_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkNotebookPage *page;
gint nchildren;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
- g_return_if_fail (child != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (tab_label == NULL || GTK_IS_WIDGET (tab_label));
+ g_return_if_fail (menu_label == NULL || GTK_IS_WIDGET (menu_label));
page = g_new (GtkNotebookPage, 1);
page->child = child;
else
{
gtk_widget_ref (page->menu_label);
- gtk_object_sink (GTK_OBJECT(page->menu_label));
+ gtk_object_sink (GTK_OBJECT (page->menu_label));
}
if (notebook->menu)
}
}
+/**
+ * gtk_notebook_remove_page:
+ * @notebook: a #GtkNotebook.
+ * @page_num: the index of a notebook page, starting
+ * from 0. If -1, the last page will
+ * be removed.
+ *
+ * Removes a page from the notebook given its index
+ * in the notebook.
+ **/
void
gtk_notebook_remove_page (GtkNotebook *notebook,
gint page_num)
* gtk_notebook_next_page
* gtk_notebook_prev_page
*/
+/**
+ * gtk_notebook_get_current_page:
+ * @notebook: a #GtkNotebook
+ *
+ * Returns the page number of the current page.
+ *
+ * Return value: the index (starting from 0) of the current
+ * page in the notebook. If the notebook has no pages, then
+ * -1 will be returned.
+ **/
gint
gtk_notebook_get_current_page (GtkNotebook *notebook)
{
- g_return_val_if_fail (notebook != NULL, -1);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
if (!notebook->cur_page)
return g_list_index (notebook->children, notebook->cur_page);
}
+/**
+ * gtk_notebook_get_nth_page:
+ * @notebook: a #GtkNotebook
+ * @page_num: the index of a page in the noteobok
+ *
+ * Returns the child widget contained in page number @page_num.
+ *
+ * Return value: the child widget, or %NULL if @page_num is
+ * out of bounds.
+ **/
GtkWidget*
gtk_notebook_get_nth_page (GtkNotebook *notebook,
gint page_num)
{
GtkNotebookPage *page;
- g_return_val_if_fail (notebook != NULL, NULL);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
page = g_list_nth_data (notebook->children, page_num);
return NULL;
}
+/**
+ * gtk_notebook_page_num:
+ * @notebook: a #GtkNotebook
+ * @child: a #GtkWidget
+ *
+ * Finds the index of the page which contains the given child
+ * widget.
+ *
+ * Return value: the index of the page containing @child, or
+ * -1 if @child is not in the notebook.
+ **/
gint
gtk_notebook_page_num (GtkNotebook *notebook,
GtkWidget *child)
GList *children;
gint num;
- g_return_val_if_fail (notebook != NULL, -1);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
num = 0;
children = notebook->children;
while (children)
{
- GtkNotebookPage *page;
-
- page = children->data;
+ GtkNotebookPage *page = children->data;
+
if (page->child == child)
return num;
return -1;
}
+/**
+ * gtk_notebook_set_page:
+ * @notebook: a #GtkNotebook
+ * @page_num: index of the page to switch to, starting from 0.
+ * If negative, or greater than the number of pages
+ * in the notebook the last page will be used.
+ *
+ * Switches to the page number @page_num.
+ **/
void
gtk_notebook_set_page (GtkNotebook *notebook,
gint page_num)
{
GList *list;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (page_num >= 0)
list = g_list_nth (notebook->children, page_num);
else
- {
- list = g_list_last (notebook->children);
- page_num = g_list_length (notebook->children) - 1;
- }
+ list = g_list_last (notebook->children);
+
+ page_num = g_list_index (notebook->children, list);
+
if (list)
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (list), page_num);
}
+/**
+ * gtk_notebook_next_page:
+ * @notebook: a #GtkNotebook
+ *
+ * Switches to the next page. Nothing happens if the current page is
+ * the last page.
+ **/
void
gtk_notebook_next_page (GtkNotebook *notebook)
{
GList *list;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
list = g_list_find (notebook->children, notebook->cur_page);
gtk_notebook_switch_page (notebook, GTK_NOTEBOOK_PAGE (list), -1);
}
+/**
+ * gtk_notebook_prev_page:
+ * @notebook: a #GtkNotebook
+ *
+ * Switches to the previous page. Nothing happens if the current page
+ * is the first page.
+ **/
void
gtk_notebook_prev_page (GtkNotebook *notebook)
{
GList *list;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
list = g_list_find (notebook->children, notebook->cur_page);
* gtk_notebook_set_tab_vborder
* gtk_notebook_set_scrollable
*/
+/**
+ * gtk_notebook_set_show_border:
+ * @notebook: a #GtkNotebook
+ * @show_border: %TRUE if a bevel should be drawn around the notebook.
+ *
+ * Sets whether a bevel will be drawn around the notebook pages.
+ * this is only has an effect when the tabs are not shown.
+ * See gtk_notebook_set_show_tabs().
+ **/
void
gtk_notebook_set_show_border (GtkNotebook *notebook,
gboolean show_border)
}
}
+/**
+ * gtk_notebook_set_show_tabs:
+ * @notebook: a #GtkNotebook
+ * @show_tabs: %TRUE if the tabs should be shown.
+ *
+ * Sets whether to show the tabs for the notebook or not.
+ **/
void
gtk_notebook_set_show_tabs (GtkNotebook *notebook,
gboolean show_tabs)
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
+/**
+ * gtk_notebook_set_tab_pos:
+ * @notebook:
+ * @pos:
+ *
+ * Sets the edge at which the tabs for switching pages in the
+ * notebook are drawn.
+ **/
void
gtk_notebook_set_tab_pos (GtkNotebook *notebook,
GtkPositionType pos)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (notebook->tab_pos != pos)
}
}
+/**
+ * gtk_notebook_set_homogeneous_tabs:
+ * @notebook: a #GtkNotebook
+ * @homogeneous: %TRUE if all tabs should be the same size.
+ *
+ * Sets whether the tabs must have all the same size or not.
+ **/
void
gtk_notebook_set_homogeneous_tabs (GtkNotebook *notebook,
gboolean homogeneous)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (homogeneous == notebook->homogeneous)
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
+/**
+ * gtk_notebook_set_tab_border:
+ * @notebook: a #GtkNotebook
+ * @tab_border: %TRUE if there should be a border around the
+ * tab labels.
+ *
+ * Sets whether there should be a border around the tab labels
+ * in a notebook. This is equivalent to calling
+ * gtk_notebook_set_tab_hborder (@notebook, @tab_border) followed
+ * by gtk_noteobok_set_tab_vborder (@notebook, @tab_border).
+ **/
void
gtk_notebook_set_tab_border (GtkNotebook *notebook,
guint tab_border)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
notebook->tab_hborder = tab_border;
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
+/**
+ * gtk_notebook_set_tab_hborder:
+ * @notebook: a #GtkNotebook
+ * @tab_vborder: %TRUE if the notebook tabs should have
+ * a vertical border.
+ *
+ * Sets whether the tabs should have a vertical border.
+ **/
void
gtk_notebook_set_tab_hborder (GtkNotebook *notebook,
guint tab_hborder)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (notebook->tab_hborder == tab_hborder)
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
+/**
+ * gtk_notebook_set_tab_vborder:
+ * @notebook: a #GtkNotebook
+ * @tab_vborder: %TRUE if the notebook tabs should have
+ * a vertical border.
+ *
+ * Sets whether the tabs should have a vertical border.
+ **/
void
gtk_notebook_set_tab_vborder (GtkNotebook *notebook,
guint tab_vborder)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (notebook->tab_vborder == tab_vborder)
gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
+/**
+ * gtk_notebook_set_scrollable:
+ * @notebook: a #GtkNotebook
+ * @scrollable: %TRUE if scroll arrows should be added
+ *
+ * Sets whether the tab label area will have arrows for scrolling if
+ * there are too many tabs to fit in the area.
+
+ **/
void
gtk_notebook_set_scrollable (GtkNotebook *notebook,
gboolean scrollable)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
scrollable = (scrollable != FALSE);
}
if (GTK_WIDGET_VISIBLE (notebook))
- gtk_widget_queue_resize (GTK_WIDGET(notebook));
+ gtk_widget_queue_resize (GTK_WIDGET (notebook));
}
}
* gtk_notebook_popup_enable
* gtk_notebook_popup_disable
*/
+
+
+/**
+ * gtk_notebook_popup_enable:
+ * @notebook: a #GtkNotebook
+ *
+ * Enables the popup menu: if the user clicks with the right mouse button on
+ * the bookmarks, a menu with all the pages will be popped up.
+ **/
void
gtk_notebook_popup_enable (GtkNotebook *notebook)
{
GList *list;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (notebook->menu)
gtk_notebook_menu_detacher);
}
+/**
+ * gtk_notebook_popup_disable:
+ * @notebook: a #GtkNotebook
+ *
+ * Disables the popup menu.
+ **/
void
gtk_notebook_popup_disable (GtkNotebook *notebook)
{
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (!notebook->menu)
* gtk_notebook_set_tab_label_packing
* gtk_notebook_query_tab_label_packing
*/
+
+/**
+ * gtk_notebook_get_tab_label:
+ * @notebook: a #GtkNotebook
+ * @child: the page
+ *
+ * Returns the tab label widget for the page @child. %NULL is returned
+ * if @child is not in @notebook or if no tab label has specifically
+ * been set for @child.
+ *
+ * Return value: the tab label
+ **/
GtkWidget *
gtk_notebook_get_tab_label (GtkNotebook *notebook,
GtkWidget *child)
{
GList *list;
- g_return_val_if_fail (notebook != NULL, NULL);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
g_return_val_if_fail (child != NULL, NULL);
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
return NULL;
if (GTK_NOTEBOOK_PAGE (list)->default_tab)
return GTK_NOTEBOOK_PAGE (list)->tab_label;
}
+/**
+ * gtk_notebook_set_tab_label:
+ * @notebook: a #GtkNotebook
+ * @child: the page
+ * @tab_label: the tab label widget to use, or %NULL for default tab
+ * label.
+ *
+ * Changes the tab label for @child. If %NULL is specified
+ * for @tab_label, then the page will have the label 'page N'.
+ **/
void
gtk_notebook_set_tab_label (GtkNotebook *notebook,
GtkWidget *child,
GtkNotebookPage *page;
GList *list;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
-
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
- return;
+
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
+ return;
/* a NULL pointer indicates a default_tab setting, otherwise
* we need to set the associated label
*/
-
page = list->data;
if (page->tab_label)
gtk_widget_unparent (page->tab_label);
}
}
+/**
+ * gtk_notebook_set_tab_label_text:
+ * @notebook: a #GtkNotebook
+ * @child: the page
+ * @tab_label: the label text
+ *
+ * Creates a new label and sets it as the tab label for the page
+ * containing @child.
+ **/
void
gtk_notebook_set_tab_label_text (GtkNotebook *notebook,
GtkWidget *child,
{
GtkWidget *tab_label = NULL;
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+
if (tab_text)
tab_label = gtk_label_new (tab_text);
gtk_notebook_set_tab_label (notebook, child, tab_label);
}
+/**
+ * gtk_notebook_get_menu_label:
+ * @notebook: a #GtkNotebook
+ * @child: the page
+ *
+ * Returns the menu label of the page containing @child. NULL is
+ * returned if @child is not in @notebook or NULL if it has the
+ * default menu label.
+ *
+ * Return value: the menu label
+ **/
GtkWidget*
gtk_notebook_get_menu_label (GtkNotebook *notebook,
GtkWidget *child)
{
GList *list;
- g_return_val_if_fail (notebook != NULL, NULL);
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
g_return_val_if_fail (child != NULL, NULL);
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
- return NULL;
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
+ return NULL;
if (GTK_NOTEBOOK_PAGE (list)->default_menu)
return NULL;
return GTK_NOTEBOOK_PAGE (list)->menu_label;
}
+/**
+ * gtk_notebook_set_menu_label:
+ * @notebook: a #GtkNotebook
+ * @child: the child widget
+ * @menu_label: the menu label, or NULL for default
+ *
+ * Changes the menu label for the page containing @child.
+ **/
void
gtk_notebook_set_menu_label (GtkNotebook *notebook,
GtkWidget *child,
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
- return;
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
+ return;
page = list->data;
if (page->menu_label)
{
if (notebook->menu)
- {
- gtk_container_remove (GTK_CONTAINER (notebook->menu),
- page->menu_label->parent);
- gtk_widget_queue_resize (notebook->menu);
- }
+ gtk_container_remove (GTK_CONTAINER (notebook->menu),
+ page->menu_label->parent);
+
if (!page->default_menu)
gtk_widget_unref (page->menu_label);
}
gtk_notebook_menu_item_create (notebook, list);
}
+/**
+ * gtk_notebook_set_menu_label_text:
+ * @notebook: a #GtkNotebook
+ * @child: the child widget
+ * @menu_text: the label text
+ *
+ * Creates a new label and sets it as the menu label of @child.
+ **/
void
gtk_notebook_set_menu_label_text (GtkNotebook *notebook,
GtkWidget *child,
{
GtkWidget *menu_label = NULL;
+ g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+
if (menu_text)
menu_label = gtk_label_new (menu_text);
gtk_notebook_set_menu_label (notebook, child, menu_label);
}
+/* Helper function called when pages are reordered
+ */
+static void
+gtk_notebook_child_reordered (GtkNotebook *notebook,
+ GtkNotebookPage *page)
+{
+ if (notebook->menu)
+ {
+ GtkWidget *menu_item;
+
+ menu_item = page->menu_label->parent;
+ gtk_container_remove (GTK_CONTAINER (menu_item), page->menu_label);
+ gtk_container_remove (GTK_CONTAINER (notebook->menu), menu_item);
+ gtk_notebook_menu_item_create (notebook, g_list_find (notebook->children, page));
+ }
+
+ gtk_notebook_update_labels (notebook);
+}
+
+/**
+ * gtk_notebook_set_tab_label_packing:
+ * @notebook: a #GtkNotebook
+ * @child: the child widget
+ * @expand: whether to expand the bookmark or not
+ * @fill: whether the bookmark should fill the allocated area or not
+ * @pack_type: the position of the bookmark
+ *
+ * Sets the packing parameters for the tab label of the page
+ * containing @child. See gtk_box_pack_start() for the exact meaning
+ * of the parameters.
+ **/
void
gtk_notebook_set_tab_label_packing (GtkNotebook *notebook,
GtkWidget *child,
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
- return;
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
+ return;
page = list->data;
if (page->pack == pack_type && page->expand == expand && page->fill == fill)
if (page->pack != pack_type)
{
page->pack = pack_type;
- if (notebook->menu)
- {
- GtkWidget *menu_item;
-
- menu_item = page->menu_label->parent;
- gtk_container_remove (GTK_CONTAINER (menu_item), page->menu_label);
- gtk_container_remove (GTK_CONTAINER (notebook->menu), menu_item);
- gtk_notebook_menu_item_create (notebook, list);
- gtk_widget_queue_resize (notebook->menu);
- }
- gtk_notebook_update_labels (notebook);
+ gtk_notebook_child_reordered (notebook, page);
}
if (!notebook->show_tabs)
return;
- gtk_notebook_pages_allocate (notebook, &(GTK_WIDGET (notebook)->allocation));
- gtk_notebook_expose_tabs (notebook);
+ gtk_notebook_pages_allocate (notebook);
}
+/**
+ * gtk_notebook_query_tab_label_packing:
+ * @notebook: a #GtkNotebook
+ * @child: the page
+ * @expand: location to store the expand value (or NULL)
+ * @fill: location to store the fill value (or NULL)
+ * @pack_type: location to store the pack_type (or NULL)
+ *
+ * Query the packing attributes for the tab label of the page
+ * containing @child.
+ **/
void
gtk_notebook_query_tab_label_packing (GtkNotebook *notebook,
GtkWidget *child,
{
GList *list;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (child != NULL);
- if (!(list = g_list_find_custom (notebook->children, child,
- gtk_notebook_page_compare)))
- return;
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
+ return;
if (expand)
*expand = GTK_NOTEBOOK_PAGE (list)->expand;
*pack_type = GTK_NOTEBOOK_PAGE (list)->pack;
}
+/**
+ * gtk_notebook_reorder_child:
+ * @notebook: a #GtkNotebook
+ * @child: the child to move
+ * @position: the new position
+ *
+ * Reorders the page containing @child, so that it appears in position
+ * @position. Out of bounds @position will be clamped.
+ **/
void
gtk_notebook_reorder_child (GtkNotebook *notebook,
GtkWidget *child,
gint position)
{
- GList *list;
- GList *work;
- GtkNotebookPage *page = NULL;
+ GList *list, *new_list;
+ GtkNotebookPage *page;
gint old_pos;
- g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
- g_return_if_fail (child != NULL);
g_return_if_fail (GTK_IS_WIDGET (child));
- for (old_pos = 0, list = notebook->children; list;
- list = list->next, old_pos++)
- {
- page = list->data;
- if (page->child == child)
- break;
- }
+ list = CHECK_FIND_CHILD (notebook, child);
+ if (!list)
+ return;
- if (!list || old_pos == position)
+ old_pos = g_list_position (notebook->children, list);
+
+ if (old_pos == position)
return;
- notebook->children = g_list_remove_link (notebook->children, list);
-
- if (position <= 0 || !notebook->children)
- {
- list->next = notebook->children;
- if (list->next)
- list->next->prev = list;
- notebook->children = list;
- }
- else if (position > 0 && (work = g_list_nth (notebook->children, position)))
- {
- list->prev = work->prev;
- if (list->prev)
- list->prev->next = list;
- list->next = work;
- work->prev = list;
- }
- else
- {
- work = g_list_last (notebook->children);
- work->next = list;
- list->prev = work;
- }
+ page = list->data;
+ notebook->children = g_list_delete_link (notebook->children, list);
- if (notebook->menu)
- {
- GtkWidget *menu_item;
+ position = CLAMP (position, 0, g_list_length (notebook->children));
- g_assert(page != NULL);
+ notebook->children = g_list_insert (notebook->children, page, position);
+ new_list = g_list_nth (notebook->children, position);
- menu_item = page->menu_label->parent;
- gtk_container_remove (GTK_CONTAINER (menu_item), page->menu_label);
- gtk_container_remove (GTK_CONTAINER (notebook->menu), menu_item);
- gtk_notebook_menu_item_create (notebook, list);
- gtk_widget_queue_resize (notebook->menu);
- }
+ /* Fix up GList references in GtkNotebook structure */
+ if (notebook->first_tab == list)
+ notebook->first_tab = new_list;
+ if (notebook->focus_tab == list)
+ notebook->focus_tab = new_list;
- gtk_notebook_update_labels (notebook);
+ /* Move around the menu items if necesary */
+ gtk_notebook_child_reordered (notebook, page);
if (notebook->show_tabs)
- {
- gtk_notebook_pages_allocate (notebook,
- &(GTK_WIDGET (notebook)->allocation));
- gtk_notebook_expose_tabs (notebook);
- }
+ gtk_notebook_pages_allocate (notebook);
}
#define GTK_NOTEBOOK_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK, GtkNotebookClass))
-#define GTK_NOTEBOOK_PAGE(_glist_) ((GtkNotebookPage *)((GList *)(_glist_))->data)
-
-
typedef struct _GtkNotebook GtkNotebook;
typedef struct _GtkNotebookClass GtkNotebookClass;
typedef struct _GtkNotebookPage GtkNotebookPage;
GtkNotebookPage *cur_page;
GList *children;
- GList *first_tab;
+ GList *first_tab; /* The first tab visible (for scrolling notebooks) */
GList *focus_tab;
GtkWidget *menu;
guint page_num);
};
-struct _GtkNotebookPage
-{
- GtkWidget *child;
- GtkWidget *tab_label;
- GtkWidget *menu_label;
-
- guint default_menu : 1;
- guint default_tab : 1;
- guint expand : 1;
- guint fill : 1;
- guint pack : 1;
-
- GtkRequisition requisition;
- GtkAllocation allocation;
-};
-
/***********************************************************
* Creation, insertion, deletion *
***********************************************************/
* query, set current NoteebookPage *
***********************************************************/
-gint gtk_notebook_get_current_page (GtkNotebook *notebook);
-GtkWidget* gtk_notebook_get_nth_page (GtkNotebook *notebook,
- gint page_num);
-gint gtk_notebook_page_num (GtkNotebook *notebook,
- GtkWidget *child);
-void gtk_notebook_set_page (GtkNotebook *notebook,
- gint page_num);
-void gtk_notebook_next_page (GtkNotebook *notebook);
-void gtk_notebook_prev_page (GtkNotebook *notebook);
+gint gtk_notebook_get_current_page (GtkNotebook *notebook);
+GtkWidget* gtk_notebook_get_nth_page (GtkNotebook *notebook,
+ gint page_num);
+gint gtk_notebook_page_num (GtkNotebook *notebook,
+ GtkWidget *child);
+void gtk_notebook_set_page (GtkNotebook *notebook,
+ gint page_num);
+void gtk_notebook_next_page (GtkNotebook *notebook);
+void gtk_notebook_prev_page (GtkNotebook *notebook);
/***********************************************************
* set Notebook, NotebookTab style *
* I wonder if focussable is a real word...
*/
if (last_column == NULL)
- {
- gtk_container_set_focus_child (container, NULL);
- return FALSE;
- }
+ return FALSE;
/* First thing we want to handle is entering and leaving the headers.
*/
if (!focus_child)
{
focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
- gtk_container_set_focus_child (container, focus_child);
gtk_widget_grab_focus (focus_child);
goto cleanup;
}
if (!focus_child)
{
focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
- gtk_container_set_focus_child (container, focus_child);
gtk_widget_grab_focus (focus_child);
goto cleanup;
}
if (!focus_child)
{
focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
- gtk_container_set_focus_child (container, focus_child);
gtk_widget_grab_focus (focus_child);
goto cleanup;
}
if (!focus_child)
{
focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
- gtk_container_set_focus_child (container, focus_child);
gtk_widget_grab_focus (focus_child);
goto cleanup;
}
if (!focus_child)
{
focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
- gtk_container_set_focus_child (container, focus_child);
gtk_widget_grab_focus (focus_child);
}
else
if (!focus_child)
{
focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
- gtk_container_set_focus_child (container, focus_child);
gtk_widget_grab_focus (focus_child);
}
else
GTK_WIDGET_CAN_FOCUS (column->button))
{
focus_child = column->button;
- gtk_container_set_focus_child (container, column->button);
gtk_widget_grab_focus (column->button);
break;
}
focus_child->allocation.x);
}
}
- else
- {
- gtk_container_set_focus_child (container, NULL);
- }
return (focus_child != NULL);
}
case GTK_DIR_TAB_BACKWARD:
return (gtk_tree_view_header_focus (tree_view, direction));
case GTK_DIR_UP:
- gtk_container_set_focus_child (container, NULL);
return FALSE;
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_RIGHT:
case GTK_DIR_DOWN:
- if (direction == GTK_DIR_DOWN)
- {
- gtk_container_set_focus_child (container, NULL);
- }
- else
+ if (direction != GTK_DIR_DOWN)
{
if (gtk_tree_view_header_focus (tree_view, direction))
return TRUE;
}
}
+/**
+ * gtk_widget_is_focus:
+ * @widget: a #GtkWidget
+ *
+ * Determines if the widget is the focus widget within its
+ * toplevel. (This does not mean that the HAS_FOCUS flag is
+ * necessarily set; HAS_FOCUS will only be set if the
+ * toplevel widget additionally has the global input focus.)
+ *
+ * Return value: %TRUE if the widget is the focus widget.
+ **/
+gboolean
+gtk_widget_is_focus (GtkWidget *widget)
+{
+ GtkWidget *toplevel;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ toplevel = gtk_widget_get_toplevel (widget);
+
+ if (GTK_IS_WINDOW (toplevel))
+ return widget == GTK_WINDOW (toplevel)->focus_widget;
+ else
+ return FALSE;
+}
+
/**
* gtk_widget_grab_default:
* @widget: a #GtkWidget
GdkRectangle *area,
GdkRectangle *intersection);
+gboolean gtk_widget_is_focus (GtkWidget *widget);
void gtk_widget_grab_focus (GtkWidget *widget);
void gtk_widget_grab_default (GtkWidget *widget);
static gint gtk_window_client_event (GtkWidget *widget,
GdkEventClient *event);
static void gtk_window_check_resize (GtkContainer *container);
+static gint gtk_window_focus (GtkContainer *container,
+ GtkDirectionType direction);
static void gtk_window_real_set_focus (GtkWindow *window,
GtkWidget *focus);
widget_class->expose_event = gtk_window_expose;
container_class->check_resize = gtk_window_check_resize;
+ container_class->focus = gtk_window_focus;
klass->set_focus = gtk_window_real_set_focus;
}
gtk_window_move_resize (window);
}
+static gboolean
+gtk_window_focus (GtkContainer *container,
+ GtkDirectionType direction)
+{
+ GtkBin *bin = GTK_BIN (container);
+ GtkWindow *window = GTK_WINDOW (container);
+ GtkWidget *old_focus_child = container->focus_child;
+ GtkWidget *parent;
+
+ /* We need a special implementation here to deal properly with wrapping
+ * around in the tab chain without the danger of going into an
+ * infinite loop.
+ */
+ if (old_focus_child)
+ {
+ if (GTK_IS_CONTAINER (old_focus_child) &&
+ GTK_WIDGET_DRAWABLE (old_focus_child) &&
+ GTK_WIDGET_IS_SENSITIVE (old_focus_child) &&
+ gtk_container_focus (GTK_CONTAINER (old_focus_child), direction))
+ return TRUE;
+ }
+
+ if (window->focus_widget)
+ {
+ /* Wrapped off the end, clear the focus setting for the toplpevel */
+ parent = window->focus_widget->parent;
+ while (parent)
+ {
+ gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
+ parent = GTK_WIDGET (parent)->parent;
+ }
+
+ gtk_window_set_focus (GTK_WINDOW (container), NULL);
+ }
+
+ /* Now try to focus the first widget in the window */
+ if (GTK_WIDGET_DRAWABLE (bin->child) &&
+ GTK_WIDGET_IS_SENSITIVE (bin->child))
+ {
+ if (GTK_IS_CONTAINER (bin->child))
+ {
+ if (gtk_container_focus (GTK_CONTAINER (bin->child), direction))
+ return TRUE;
+ }
+ else if (GTK_WIDGET_CAN_FOCUS (bin->child))
+ {
+ gtk_widget_grab_focus (bin->child);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
static void
gtk_window_real_set_focus (GtkWindow *window,
GtkWidget *focus)
GtkWidget *sample_notebook;
static void
-page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
+set_page_pixmaps (GtkNotebook *notebook, gint page_num,
+ GdkPixmap *pixmap, GdkPixmap *mask)
{
- GtkNotebookPage *oldpage;
+ GtkWidget *page_widget;
GtkWidget *pixwid;
- oldpage = GTK_NOTEBOOK (widget)->cur_page;
+ page_widget = gtk_notebook_get_nth_page (notebook, page_num);
+
+ pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "tab_pixmap");
+ gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+
+ pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
+ gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+}
- if (page == oldpage)
+static void
+page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
+{
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ gint old_page_num = gtk_notebook_get_current_page (notebook);
+
+ if (page_num == old_page_num)
return;
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (page->tab_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (page->menu_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
-
- if (oldpage)
- {
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (oldpage->tab_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (oldpage->menu_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- }
+
+ set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
+
+ if (old_page_num != -1)
+ set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
}
static void
label_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
+
gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (label_box);
+
menu_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ gtk_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid);
+
gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (menu_box);
+
gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
}
}
gint i;
gtk_notebook_set_show_tabs (notebook, TRUE);
+ gtk_notebook_set_show_border (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, FALSE);
if (g_list_length (notebook->children) == 15)
for (i = 0; i < 10; i++)
gint i;
gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, TRUE);
+ if (g_list_length (notebook->children) == 15)
+ for (i = 0; i < 10; i++)
+ gtk_notebook_remove_page (notebook, 5);
+}
+
+static void
+borderless_notebook (GtkButton *button,
+ GtkNotebook *notebook)
+{
+ gint i;
+
+ gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, FALSE);
if (g_list_length (notebook->children) == 15)
for (i = 0; i < 10; i++)
gtk_notebook_remove_page (notebook, 5);
GtkNotebook *notebook)
{
gtk_notebook_set_show_tabs (notebook, TRUE);
+ gtk_notebook_set_show_border (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, TRUE);
if (g_list_length (notebook->children) == 5)
create_pages (notebook, 6, 15);
{
{ "Standard", standard_notebook },
{ "No tabs", notabs_notebook },
- { "Scrollable", scrollable_notebook }
+ { "Borderless", borderless_notebook },
+ { "Scrollable", scrollable_notebook },
};
if (!window)
label = gtk_label_new ("Notebook Style :");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
- omenu = build_option_menu (items, 3, 0, sample_notebook);
+ omenu = build_option_menu (items, G_N_ELEMENTS (items), 0, sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Show all Pages");
GtkWidget *sample_notebook;
static void
-page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
+set_page_pixmaps (GtkNotebook *notebook, gint page_num,
+ GdkPixmap *pixmap, GdkPixmap *mask)
{
- GtkNotebookPage *oldpage;
+ GtkWidget *page_widget;
GtkWidget *pixwid;
- oldpage = GTK_NOTEBOOK (widget)->cur_page;
+ page_widget = gtk_notebook_get_nth_page (notebook, page_num);
+
+ pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "tab_pixmap");
+ gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+
+ pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
+ gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+}
- if (page == oldpage)
+static void
+page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
+{
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ gint old_page_num = gtk_notebook_get_current_page (notebook);
+
+ if (page_num == old_page_num)
return;
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (page->tab_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (page->menu_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
-
- if (oldpage)
- {
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (oldpage->tab_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (oldpage->menu_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- }
+
+ set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
+
+ if (old_page_num != -1)
+ set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
}
static void
label_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
+
gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (label_box);
+
menu_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ gtk_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid);
+
gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (menu_box);
+
gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
}
}
gint i;
gtk_notebook_set_show_tabs (notebook, TRUE);
+ gtk_notebook_set_show_border (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, FALSE);
if (g_list_length (notebook->children) == 15)
for (i = 0; i < 10; i++)
gint i;
gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, TRUE);
+ if (g_list_length (notebook->children) == 15)
+ for (i = 0; i < 10; i++)
+ gtk_notebook_remove_page (notebook, 5);
+}
+
+static void
+borderless_notebook (GtkButton *button,
+ GtkNotebook *notebook)
+{
+ gint i;
+
+ gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, FALSE);
if (g_list_length (notebook->children) == 15)
for (i = 0; i < 10; i++)
gtk_notebook_remove_page (notebook, 5);
GtkNotebook *notebook)
{
gtk_notebook_set_show_tabs (notebook, TRUE);
+ gtk_notebook_set_show_border (notebook, TRUE);
gtk_notebook_set_scrollable (notebook, TRUE);
if (g_list_length (notebook->children) == 5)
create_pages (notebook, 6, 15);
{
{ "Standard", standard_notebook },
{ "No tabs", notabs_notebook },
- { "Scrollable", scrollable_notebook }
+ { "Borderless", borderless_notebook },
+ { "Scrollable", scrollable_notebook },
};
if (!window)
label = gtk_label_new ("Notebook Style :");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
- omenu = build_option_menu (items, 3, 0, sample_notebook);
+ omenu = build_option_menu (items, G_N_ELEMENTS (items), 0, sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Show all Pages");
projects / gtk4.git / commitdiff